java实现多线程的方式并源码分析

个人资源与分享网站：首页-小草资源分享网站

方式一：继承Thread

定义一个MyThread类，重写run方法

public class MyThred extends Thread{

    @Override
    public void run() {
        System.out.println("MyThread.run()");
    }    
}

Thread本身实现了Runnable接口

为什么调用start()方法会执行对应的run（）方法？Thread类源码如下：

Thread类的主要方法如下：

public synchronized void start() {
       
        if (threadStatus != 0)
            throw new IllegalThreadStateException();
        group.add(this);

        boolean started = false;
        try {
            start0();
            started = true;
        } finally {
            try {
                if (!started) {
                    group.threadStartFailed(this);
                }
            } catch (Throwable ignore) {
              
            }
        }
    }

private native void start0();

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

程序运行结果：

MyThread.run()

方式二：实现runnable接口

应用场景：因为java只允许单继承，当一个类已经继承了另一个类的时候，可以通过实现runnable接口来实现多线程

public class MyThred extends A implements Runnable{

    public void run() {
        System.out.println("MyThread.run()");
        
    }    
}

MyThred 实现了Runnable接口，就必须实现里面的抽象方法run()

运行结果：

MyThread.run()

方式三：通过Callable和FutureTask创建线程

@SuppressWarnings("hiding")
public class MyThred<Object> implements Callable<Object>{

    public Object call() throws Exception {
        System.out.println(Thread.currentThread().getName()+"-->我是通过实现Callable接口通过FutureTask包装器来实现的线程");
        return null;
    }   
}

public class App 
{
    public static void main(String[] args) {
        Callable<Object> oneCallable = new MyThred<Object>();
        FutureTask<Object> oneTask = new FutureTask<Object>(oneCallable);

        Thread t = new Thread(oneTask);

        System.out.println(Thread.currentThread().getName());

        t.start();

    }
    
    
}

源码分析：

FutureTask构造方法、run方法

public FutureTask(Callable<V> callable) {
        if (callable == null)
            throw new NullPointerException();
        this.callable = callable;
        this.state = NEW;       // ensure visibility of callable
    }

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 {
            // runner must be non-null until state is settled to
            // prevent concurrent calls to run()
            runner = null;
            // state must be re-read after nulling runner to prevent
            // leaked interrupts
            int s = state;
            if (s >= INTERRUPTING)
                handlePossibleCancellationInterrupt(s);
        }
    }

代码执行流程：Thread对象的start()方法，target为oneTask，执行的run()就是FutureTask类的run方法，最终执行oneCallable的call()方法

方式四：使用线程池的方式

public class App 
{
    public static void main(String[] args) {
        ExecutorService threadPool=Executors.newFixedThreadPool(10);
        while(true) {
            threadPool.execute(new Runnable() {
                
                public void run() {
                    System.out.println(Thread.currentThread().getName()+"is running...");
                    try {
                        Thread.sleep(3000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            });
        }
        
    }
    
    
}