创建线程的三种方式

雨点打透心脏的1/2处 2022-05-31 10:41 267阅读 0赞

# 线程的创建 #

创建线程具体来说有三种方式，详细内容如下文．

## 继承Thread类 ##

### 详细步骤：    ###

1．定义Thread类的子类，并重写该类的run()方法，run()方法被称为线程执行体．

2．创建Thread子类的实例，即创建线程对象．

3．调用线程对象的start()方法启动该线程．

### 代码示例： ###

/**
     * Created by dongmengyuan on 18-2-21.
     */
    
    public class FirstThread extends Thread {
        //i是FirstThread的实例属性，不是局部变量
        private int i;
        //重写run()方法，run()方法的方法体是线程执行体
        public void run() {
            for( ; i < 100; i++) {
                //当线程使用继承Thread类时，直接使用this就可以获取当前线程
                //Thread对象的getName()返回当前线程的名字
                //直接调用getName()方法返回当前线程的名字
                System.out.println(getName() + " " + i);
            }
        }
    
        public static void main(String[] args) {
            for(int i = 0; i < 100; i++) {
                //调用Thread的currentThread()方法获取当前线程
                System.out.println(Thread.currentThread().getName() + " " + i);
                if(i == 20) {
                    //创建并启动第一个线程
                    new FirstThread().start();
                    //创建并启动第二个线程
                    new FirstThread().start();
                }
            }
    
        }
    }

上面程序显式的创建了两个线程，但是实际上程序有三个线程，其中包括主线程．

当Java程序开始运行时，程序至少会创建一个主线程，主线程的执行体不是由run()方法确定的，而是由main()方法确定的．

＊使用继承Thread类的方法创建线程时，多个线程之间无法共享线程类的实例变量．

## 实现Runnable接口 ##

### 详细步骤： ###

1．定义Runnable接口的实现类，并重写该接口的run()方法．

2．创建Runnable实现类的实例，并以此实例作为Thread的target来创建Thread对象，该Thread对象才是真正的线程对象．

3．调用线程对象的start()方法来启动该线程．

### 代码示例： ###

/**
     * Created by dongmengyuan on 18-2-21.
     */
    
    public class SecondThread implements Runnable {
        private int i;
    
        public void run() {
            //当线程类实现Runnable接口时，如果想要获取当前线程，只能用Thread.currentThread()方法
            System.out.println(Thread.currentThread() + " " + i);
        }
    
        public static void main(String[] args) {
            for(int i = 0; i < 100; i++) {
                System.out.println(Thread.currentThread().getName() + " " + i);
                if(i == 20) {
                    SecondThread st = new SecondThread();
                    //通过new Thread(target,name)方法创建新线程
                    new Thread(st, "新线程1").start();
                    new Thread(st, "新线程2").start();
                }
            }
    
        }
    }

＊采用Runnable接口的方式创建的多个线程可以共享线程类的实例属性．因为这种方式下，程序所创建的Runnable对象只是线程的target,多个线程可以共享同一个target．

# 使用Callable和Future #

### 详细步骤： ###

1．创建Callable接口的实现类，并实现call()方法，该call()方法作为线程执行体，且该call()方法有返回值．

2．创建Callable实现类的实例，使用Future Task类来包装Callable对象，该Future Task对象封装了Callable对象的call()方法的返回值．

3．使用Future Task对象作为Thread对象的target创建并启动新线程．

4．调用Future Task对象的get()方法来获得子线程执行结束后的返回值．

### 代码示例： ###

import java.util.concurrent.Callable;
    import java.util.concurrent.FutureTask;
    
    /**
     * Created by dongmengyuan on 18-2-22.
     */
    
    public class ThirdThread implements Callable<Integer> {
        //实现call()方法，作为线程执行体
        //call()方法可以有返回值
        public Integer call() {
            int i = 0;
            for(; i < 100; i++) {
                System.out.println(Thread.currentThread().getName() + " 的循环变量i的值：　" + i);
            }
            return i;
        }
    
        public static void main(String[] args) {
            //创建Callable对象
            ThirdThread rt  = new ThirdThread();
            //使用Future Task对象来包括Callable对象
            FutureTask<Integer> task = new FutureTask<Integer>(rt);
            for(int i = 0; i < 100; i++) {
                System.out.println(Thread.currentThread().getName() + " 的循环变量i的值：　" + i);
                if(i == 20) {
                    //实质还是以Callable对象来创建并启动线程
                    new Thread(task,"有返回值的线程").start();
                }
            }
            try {
                //获取线程返回值
                System.out.println("子线程的返回值：" + task.get());
            }
            catch (Exception ex) {
                ex.printStackTrace();
            }
        }
    }

＊call()方法比run()方法功能更强大．　　－－－call()方法可以有返回值，可以声明抛出异常．

＊Callable接口有泛型限制，Callable接口里的泛型形参类型与call()方法返回值类型相同．

## 创建线程的三种方式对比 ##

实现Runnable接口和实现Callable接口的方式基本相同，只是Callable接口里定义的方法有返回值，可以声明抛出异常，大体上可以归结为一大类，这种方式与继承Thread方式之间的主要差别是：

**采用实现Runnable，Callable接口创建多线程**

１．线程类只是实现了Runnable接口或Callable接口，还可以继承其他类

2．多个线程可以共享同一个target对象，非常适合多个相同线程来处理同一份资源的情况．（面向对象）

3．如果要访问当前线程，必须使用Thread.currentThread()方法，比较复杂

**    采用继承Thread类的方式创建多线程**

1．因为线程类已经继承了Thread类，所以不能再继承其他父类

2．如果要访问当前线程，直接使用this即可获得

鉴于上述分析，通常推荐使用实现接口的方式来创建多线程，实现接口的方式比继承类的方式更灵活，也能减少程序之间的耦合度，面向接口编程也是设计模式６大原则的核心．