【并发编程】创建线程的三种方法

╰半橙微兮° 2024-03-16 20:02 38阅读 0赞

## 源码 ##

### Runnable ###

函数式接口

package java.lang;  
    @FunctionalInterface  
    public interface Runnable {
          
    public abstract void run();  
    }

### Thread ###

就是一个典型的静态代理模式

public   class Thread implements Runnable {
        
    	private Runnable target;
    	public Thread() {
          
    	    init(null, null, "Thread-" + nextThreadNum(), 0);  
        }  
        public Thread(Runnable target) {
          
    	    init(null, target, "Thread-" + nextThreadNum(), 0);  
    	}
    	@Override  
    	public void run() {
          
    	    if (target != null) {
          
    	        target.run();  
    	    }  
    	}
    }

### FutureTask ###

FutureTask的run()实际上调用的是Callable的call()方法，返回的realut可以通过get()方法获取

public void run() {
          
        if (state != NEW ||  
            !UNSAFE.compareAndSwapObject(this, runnerOffset,  
                                         null, Thread.currentThread()))  
            return;  
        try {
          
            Callable<V> c = callable;  
            if (c != null && state == NEW) {
          
                V result;  
                boolean ran;  
                try {
          
                    result = c.call();  
                    ran = true;  
                } catch (Throwable ex) {
          
                    result = null;  
                    ran = false;  
                    setException(ex);  
                }  
                if (ran)  
                    set(result);  
            }  
        } finally {
           
            if (s >= INTERRUPTING)  
                handlePossibleCancellationInterrupt(s);  
        }  
    }
    protected void set(V v) {
          
        if (UNSAFE.compareAndSwapInt(this, stateOffset, NEW, COMPLETING)) {
          
            outcome = v;  
            UNSAFE.putOrderedInt(this, stateOffset, NORMAL); // final state  
            finishCompletion();  
        }  
    }
    
    
    
    
    
    
    public V get() throws InterruptedException, ExecutionException {
          
        int s = state;  
        if (s <= COMPLETING)  
            s = awaitDone(false, 0L);  
        return report(s);  
    }
    private V report(int s) throws ExecutionException {
          
        Object x = outcome;  
        if (s == NORMAL)  
            return (V)x;  
        if (s >= CANCELLED)  
            throw new CancellationException();  
        throw new ExecutionException((Throwable)x);  
    }

### 类图 ###

![image.png][]

## 一、继承Thread ##

继承Thread,重写run方法

@Test  
        public void test2(){
          
            // 创建线程对象  
            Thread t = new subThread();  
            // 启动线程  
            t.start();  
        }  
    
    class subThread extends Thread{
          
        @Override  
        public void run() {
          
            System.out.println("任务1");  
        }  
    }

或者

匿名子类

@Test  
    public void test1(){
          
        // 创建线程对象  
        Thread t = new Thread() {
          
            @Override  
            public void run() {
          
                System.out.println("任务1.1");  
            }  
        };  
        // 启动线程  
        t.start();  
    }

## 二、给Thred对象传入Runnable对象（推荐） ##

@Test  
        public void test3(){
          
            Runnable runnable = new RunnableImpl();  
            Thread thread = new Thread(runnable);  
            thread.start();  
        }  
    
    class RunnableImpl implements  Runnable{
          
        @Override  
        public void run() {
          
            System.out.println("任务2");  
        }  
    }

推荐写法，使用lamada表达式生成Runable的匿名内部类对象，再传给Thred对象。  
把任务和线程分开，更加灵活

@Test  
    public void test4(){
          
        Runnable runnable = () -> System.out.println("任务2.2");  
        Thread thread = new Thread(runnable);  
        thread.start();  
    }

原理  
Thread的run方法，使用到了静态代理模式，执行thred对象的run实际上执行的是匿名Runnable实现类对象的run方法。

@Override  
    public void run() {
          
        if (target != null) {
          
            target.run();  
        }  
    }

## 三、给Thread对象传入FutureTask对象 ##

@Test  
    public void test5() throws ExecutionException, InterruptedException {
          
        // 创建任务对象  
        FutureTask<Integer> task3 = new FutureTask<>(() -> {
          
            System.out.println("任务3");  
            return 100;  
        });  
        // 参数1 是任务对象; 参数2 是线程名字，推荐  
        new Thread(task3, "t3").start();  
        // 主线程阻塞，同步等待 task 执行完毕的结果  
        Integer result = task3.get();  
        System.out.println(result);  
      
    }

[image.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/15/a61002e6400a45889d72080ab179c648.png