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

梦里梦外; 2021-09-24 05:16 197阅读 0赞

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

**方式一：继承Thread**

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

public class MyThred extends Thread\{

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

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3hpYW8yOTczMjg_size_16_color_FFFFFF_t_70][]

![20200427192431611.png][]

![20200427192536402.png][]

Thread本身实现了Runnable接口

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

Thread类的主要方法如下：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3hpYW8yOTczMjg_size_16_color_FFFFFF_t_70 1][]

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()");  
          
    \}      
\}

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3hpYW8yOTczMjg_size_16_color_FFFFFF_t_70 2][]

![20200428094554774.png][]

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();

\}  
      
      
\}

源码分析：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3hpYW8yOTczMjg_size_16_color_FFFFFF_t_70 3][]

![20200428143305428.png][]

![2020042814332488.png][]

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();  
                    \}  
                \}  
            \});  
        \}  
          
    \}  
      
      
\}

[-]: http://xiaocaoshare.com/
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3hpYW8yOTczMjg_size_16_color_FFFFFF_t_70]: /images/20210923/76f98444fa3840b0b148ee05ce2249ab.png
[20200427192431611.png]: /images/20210923/1446403784164cfeaaaef574669761ea.png
[20200427192536402.png]: /images/20210923/7855d259e6cd49c4af604c31ac5c4555.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3hpYW8yOTczMjg_size_16_color_FFFFFF_t_70 1]: /images/20210923/95700cb752b1471eb8978f8d3d1d6f61.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3hpYW8yOTczMjg_size_16_color_FFFFFF_t_70 2]: /images/20210923/706dab17093648b9bb3c31cc07aa7652.png
[20200428094554774.png]: /images/20210923/d01ba9c7d4d84e1885e9824403a729e3.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3hpYW8yOTczMjg_size_16_color_FFFFFF_t_70 3]: /images/20210923/1cac05fc7252497084159dcc70fbe125.png
[20200428143305428.png]: /images/20210923/5b660f74417d4f8995783c71182681c6.png
[2020042814332488.png]: /images/20210923/59722954eb8b41baa114a627333f47bc.png