线程的创建方法

小鱼儿 2024-03-23 21:48 33阅读 0赞

#### 文章目录 ####

*  方法1 继承Thread类并重写run
 *  方法2 实现Runnable接口
 *  方法3使用callable接口重写call方法
 *  方法4 使用线程池创建线程

## 方法1 继承Thread类并重写run ##

1.  继承 Thread 来创建一个线程类.，并重写run方法

class MyThread extends Thread {
         
        @Override
        public void run() {
        
            System.out.println("这里是线程运行的代码"); 
        }
    }

1.  创建 MyThread 类的实例

MyThread t = new MyThread();
    //或者
    //Thread t = new MyThread();

1.  调用 start 方法启动线程

t.start();  // 线程开始运行

创建mythread类并继承thread并重写run方法；实例化一个mythread为对象t，并调用t。start方法

## 方法2 实现Runnable接口 ##

1.  实现 Runnable 接口

class MyRunable implements Runnable{
        
        public void run(){
        
        }
    }

1.  创建 Thread 类实例, 调用 Thread 的构造方法时将 Runnable 对象作为 target 参数

Thread t = new Thread(new MyRunnable());

1.  调用 start 方法

t.start();  // 线程开始运行

示例

package thread;
    //Runable的作用是描述一个要执行的任务，run方法就是任务的执行细节。
    class MyRunable implements Runnable{
        
        public void run(){
        
            System.out.println("执行Runable");
    
        }
    }
    
    public class ThreadDemo2 {
        
        public static void main(String[] args) {
        
            Runnable runnable =  new MyRunable();
            Thread t = new Thread(runnable);
            t.start();
        }
    }

![在这里插入图片描述][ad32e7e417564bdfba461bbdffaca269.png]构建myRunable类实现runable接口，重写run方法，主函数实例化myRunable,将实例化对象作为参数传输new thread，执行start方法；

上述两种方式的区别

1.  继承 Thread 类, 直接使用 this 就表示当前线程对象的引用.
2.  实现 Runnable 接口, this 表示的是 MyRunnable 的引用. 需要使用 Thread.currentThread()来获取当前线程对象的引用
3.  在逻辑上就是将线程和线程本身要做的任务分开，也就是解耦合；目的是为了未来如果需要改动代码，不用多线程而使用多进程，线程池等，代码改动会小一点。

同时上述方式可以使用lambada表达式和匿名内部类的方式进行简化

Thread thread1  = new Thread(new Runnable() {
        
                @Override
                public void run() {
        
    
                    while(true){
        
                        System.out.println("线程方法体1");
                    }
                }
            });
    
            Thread thread2 = new Thread(){
        
                @Override
                public void run() {
        
                    while(true){
        
                        System.out.println("线程方法体2");
                    }
                }
            };

## 方法3使用callable接口重写call方法 ##

public class ThreadDemo32 {
        
        public static void main(String[] args)  {
        
            Callable<Integer> callable = new Callable<Integer>() {
        
                @Override
                public Integer call() throws Exception {
        
                    return null;
                }
            };
            FutureTask<Integer> futureTask = new FutureTask<Integer>(callable);
            Thread thread = new Thread(futureTask);
            thread.start();
        }
    }

Callable 是一个 interface . 相当于把线程封装了一个 “返回值”. 方便程序猿借助多线程的方式计算 结果.  
Callable 和 Runnable 相对, 都是描述一个 “任务”. Callable 描述的是带有返回值的任务,  
Runnable 描述的是不带返回值的任务.  
Callable 通常需要搭配 FutureTask 来使用. FutureTask 用来保存 Callable 的返回结果. 因为 Callable 往往是在另一个线程中执行的, 啥时候执行完并不确定.FutureTask 就可以负责这个等待结果出来的工作.  
所以相对来说，使用callable要少使用很多wait,notify，sychronized

## 方法4 使用线程池创建线程 ##

线程池的创建方法非常多，我们这里举例几种

使用固定形式的线程  
调用Executor类的静态方法newFixedTheadPool，实例化ExcutorSevice 对象  
使用ExcutorSevice的成员方法submit注册执行体

public class Test {
        
        public static void main(String[] args) {
        
            ExecutorService executors = Executors.newFixedThreadPool(2);
            executors.submit(new Runnable() {
        
                @Override
                public void run() {
        
                    while(true){
        
                        System.out.println("线程1");
                    }
    
                }
            });
            executors.submit(new Runnable() {
        
                @Override
                public void run() {
        
                    while(true){
        
                        System.out.println("线程2");
                    }
                }
            });
            //默认直接抛弃了，所以线程三根本不会提交到线程池中
            executors.submit(new Runnable() {
        
                @Override
                public void run() {
        
                    while(true){
        
                        System.out.println("线程3");
                    }
                }
            });
        }
    }

实例化自定义线程池ThreadPoolExcutor，调用ThreadPoolExcutor的submit方法提交方法体

public class Test {
        
        public static void main(String[] args) {
        
            ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(3, 10, 1, TimeUnit.SECONDS, new ArrayBlockingQueue<Runnable>(10));
            for (int i = 0; i < 3; i++) {
        
                int c = i;
                threadPoolExecutor.submit(new Runnable() {
        
                    int d = c;
                    @Override
                    public void run() {
        
                        while (true) {
        
                            System.out.println("线程" + d);
                        }
                    }
                });
            }
        }
    }

[ad32e7e417564bdfba461bbdffaca269.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/6a488c7879c74922afe05ffd2dafb05d.png