线程的3种创建方式

迷南。 2022-07-24 05:09 211阅读 0赞

所有的线程对象都是Thread类或其子类的实例。

# **1.通过继承Thread类创建线程类** #

## 1.步骤 ##

1.  定义Thread类的子类FirstThread，并重写run()方法。run()方法的方法体（**线程执行体**）就是线程要执行的任务。
2.  创建FirstThread类的实例。
3.  调用子类实例的star()方法来**启动**线程。

## 2.代码： ##

public class FirstThread extends Thread{     
        private int i;
        //重写run方法，
        public void run(){
            for(;i<1000 ;i++){
                System.out.println(getName()+" "+i);
                //之所以可以直接调用Therad类的getName()方法，是因为该类继承了Thread类
            }
        }
    
        public static void main(String[] args)  {
            for(int i=0;i<100;i++){
                //获取当前线程：这里是主线程 
                System.out.println("当前线程："+Thread.currentThread().getName()+" "+i);
                if(i == 20){
                    //启动第一个线程
                    new FirstThread().start();
                    //启动第二个线程
                    new FirstThread().start();
                }
    
            }
    
        }
    }

部分结果：

Thread-1   731
    Thread-0   16
    Thread-1   732
    Thread-0   17
    Thread-1   733
    Thread-0   18
    Thread-1   734
    Thread-0   19

## 3.分析结果 ##

从结果可以看出，第一个线程与第二个线程在交替运行。而且，我们可以发现，线程1的变量从i从731到734连续，而线程2从16到19连续。这说明，虽然 i 是FirstThread类的实例变量而非局部变量，但因为程序每次创建线程时，都会创建一个对象（new FirstThread），所以线程1与线程2不会共享 i 这个实例变量。  
所以，通过继承Thread类创建线程类时，多个线程之间**无法共享该线程类的实例变量**。

# **2.实现Runnable接口方式创建线程类** #

## 1.步骤 ##

1.  定义Runnable接口实现类SecondThread类，并重写该接口的run()方法
2.  创建SecondThread的实例st
3.  以st作为target创建Thread对象，该**Thread对象才是真正的线程对象**啊，只不过该Thread线程，只负责执行target里的run()方法。
4.  调用线程对象的start()方法**启动**。

## 2.代码 ##

public class SecondThread implements Runnable { 
        private int i;
        @Override
        public void run() {
            for(;i<1000;i++){
                System.out.println(Thread.currentThread().getName()+" "+i);
                //实现Runnable接口时，只能使用Thread类调用当前线程
            }
    
        }
    
        public static void main(String[] args) {
            SecondThread st = new SecondThread();//创建线程的target
            for(int i=0;i<100;i++){
                if(i==20){
                    new Thread(st,"线程1").start();
                    new Thread(st, "线程2").start();//两种方式
                }
            }
    
        }
    
    }

结果片段1：

线程1 0
    线程2 0
    线程2 1
    线程2 2
    线程2 3
    线程2 5
    线程2 6

结果片段2：

线程2 306
    线程2 307
    线程1 4
    线程1 308
    线程1 309

## 分析结果 ##

我们会发现，结果1片段中 i 变量没有4，而是出现在了片段2中，而且线程2当中没有i=4这个变量，则线程1就会有，即**两个线程共享 i 这个变量**。  
所以，程序创建的SecondThread对象只是Thread类构造Thread(Runnable target, String name)中的target，该**target可被多个线程共享**。

# **3.使用Callable和Future创建线程** #

Callabled接口有点儿像是Runnable接口的增强版，它**以call()方法作为线程执行体**，call()方法比run()方法功能更强大。  
**call()方法可以有返回值，可以声明抛出异常类**。  
获取call()方法里的返回值: 通过FutureTask类（实现Future接口）的实例对象的get()方法得到，得到结果类型与创建TutureTask类给的泛型一致。

## 1. 步骤 ##

1、 定义实现Callable接口的实现类，并实现call()方法。注意：Callable有泛型限制，与返回值类型一致。这里是Integer

public class ThirdThread implements Callable<Integer>{ //重写call()方法}

2、 再创建Callable实现类的实例tt。

ThirdThread tt = new ThirdThread();

3、 使用FutureTask类包装Callable的实例tt。

FutureTask<Integer> task = new FutureTask<Integer>(tt);//注意：泛型限制与返回结果一致。

4、以FutureTask对象（task）作为Thread的target来创建线程，并启动。

new Thread(task, "线程").start();

5、调用FutureTask对象（task）的get()方法获得返回值

Integer result = task.get();//会有异常

## 2.代码 ##

public class ThirdThread implements Callable<Integer>{
    
        private int i;
        @Override
        public Integer call() throws Exception {
            for(;i<100;i++){
                System.out.println(Thread.currentThread().getName()+" "+i);
            }
            return i;
        }
    
        public static void main(String[] args) {
            //创建Callable对象
            ThirdThread tt = new ThirdThread();
            FutureTask<Integer> task = new FutureTask<Integer>(tt);
            for(int i=0;i<1000;i++){
                System.out.println(Thread.currentThread().getName()+" "+i);
                if(i == 20){
                    //创建线程 
                    new Thread(task, "线程").start();
                }
            }
            try {
                //获取线程返回值
                Integer result = task.get();
                System.out.println(result);
            } catch (InterruptedException e) { 
                e.printStackTrace();
            } catch (ExecutionException e) {
                e.printStackTrace();
            }
        }
    
    }

## 3.结果分析 ##

结果是，只能new一个Thread，即单线程，所以这么写于多线程是行不通的。需要创建一个能执行多个任务的服务。

## 4.Future接口控制Callable里任务的几个方法 ##

1.  boolean **cancel**(boolean mayInterruptIfRunning) : 试图取消Callable里的任务，即中断线程。不一定会成功。
2.  V **get()** : 得到Callable任务里call()方法的返回值 。调用该方法将会**导致主线程被主阻塞**。必须要等到**子线程结束后才会得到返回值**，**得到返回值 后，主线程才能继续往下执行**。
3.  V get(long timeout,TimeUnit unit) : 也是得到返回值，但该方法会让程序阻塞timeout和unit指定的时间，若指定时间后还没有返回值 ，则抛出TimeoutException异常。
4.  boolean **isCanceled()** : 如果在任务结束前被取消了，该方法就会返回true.
5.  boolean **isDone()** : 如果Callalbe任务已完成，则返回true。

## 5.Callable接口方式的多线程示例 ##

**代码**：

public class CallableAndFuture {   
        public static class MyCallableClass implements Callable {   
    
            private int i = 0;  
    
            public Integer call() throws Exception {  
                for(;i<1000;i++){
                    System.out.println(Thread.currentThread().getName()+" "+i);
                }
                return i; 
            }  
        }  
    
        public static void main(String[] args) {  
            // 定义3个Callable类型的任务 
            MyCallableClass task1 = new MyCallableClass();  
            MyCallableClass task2 = new MyCallableClass();  
            MyCallableClass task3 = new MyCallableClass();  
    
            // 创建一个执行任务的服务 
            ExecutorService es = Executors.newFixedThreadPool(3); 
            try {  
                // 提交并执行任务，任务启动时返回了一个Future对象， 
                // 如果想得到任务执行的结果或者是异常可对这个Future对象进行操作 
                Future future1 = es.submit(task1);  
                // 如果调用get方法，当前线程会等待任务执行完毕后才往下执行 
               // System.out.println("task1: " + future1.get()); 
    
                Future future2 = es.submit(task2);  
                //System.out.println("task2 cancel: " + future2.cancel(true)); 
    
                // 获取第三个任务的输出，因为执行第三个任务会引起异常 
                // 所以下面的语句将引起异常的抛出 
                Future future3 = es.submit(task3);  
                //System.out.println("task3: " + future3.get()); 
            } catch (Exception e) {  
                System.out.println(e.toString());  
            }  
            // 停止任务执行服务 
            es.shutdownNow();  
        }  
    }

**结果片段**：

pool-1-thread-2 502
    pool-1-thread-3 867
    pool-1-thread-2 503
    pool-1-thread-3 868
    pool-1-thread-2 504
    pool-1-thread-3 869
    pool-1-thread-2 505
    pool-1-thread-3 870
    pool-1-thread-2 506
    pool-1-thread-3 871
    pool-1-thread-2 507

**结果分析**：  
只要不调用get()方法，就不会阻塞，多个线程之间会交替执行；从序号可看出，每个线程的都是连续的，所以每个线程之间**不共享实例变量 i** ，这跟Thread方式是一样的。原因是每个线程我们都new了一个task的。

# **4.三种创建方式区别** #

首先三种方式都可以创建多线程。  
**Thread方式和Callable方式不能共享实例变量；而Runnalbe方式可共享，因为能共享target。**  
因为通过实现Runnable接口与Callable接口类似，只是Callable接口方式的call(）方法有返回值和可声明抛出异常，所以我们将这两种方式统称为RC方式。通过继承Thread类方式称为T方式。

## 1. RC方式优缺点： ##

1.  **优点**：  
    
    
    1.  还可以继承其他类。
    2.  多个线程可共享一个target对象。适用于多个线程处理同一份资源的情况。
2.  **缺点**：  
    编程稍稍复杂些。

## 2. T方式优缺点： ##

1.  **优点**：  
    编程简单。
2.  **缺点**：  
    因为单继承的限制，不能再继承其他类了。

综上分析：最好采用RC方式。