【并发编程】线程实现方式

雨点打透心脏的1/2处 2022-03-22 08:37 234阅读 0赞

# 前言 #

Github：[https://github.com/yihonglei/jdk-source-code-reading][https_github.com_yihonglei_jdk-source-code-reading]（java-concurrent）

# 一 线程 #

JVM中的线程是和OS中的线程一一对应的，是进程的一个实体，是CPU调度和分派的基本单位，

它是比进程更小的独立运行的基本单元，由操作系统负责调度所有的线程，因此在不同的平台上，Java线程的优先级有所不同。

# 二 线程实现方式 #

常用实现方式：Runnable，Thread，Callable。

## 1、实现Runnable接口 ##

通过实现Runnable接口，实现run方法创建线程。

package com.jpeony.concurrent.thread;
    
    /**
     * 通过实现Runnable接口，实现run方法，创建线程
     *
     * @author yihonglei
     */
    public class MyRunnable implements Runnable {
        @Override
        public void run() {
            System.out.println("通过实现Runnable接口创建线程");
        }
    
        public static void main(String[] args) {
            MyRunnable runnable = new MyRunnable();
            Thread thread = new Thread(runnable);
            thread.start();
            System.out.println("多线程技术--代码运行结果与代码执行顺序或调用顺序无关");
        }
    }

在java线程中，无论用什么方式，本质上都要实现Runnable接口。

## 2、继承Thread ##

继承Thread，重写run方法创建线程。

package com.jpeony.concurrent.thread;
    
    /**
     * 通过继承Thread类，重写run方法，创建线程
     *
     * @author yihonglei
     */
    public class MyThread extends Thread {
        @Override
        public void run() {
            System.out.println("通过继承Thread创建线程");
        }
    
        public static void main(String[] args) {
            MyThread thread = new MyThread();
            thread.start();
            System.out.println("多线程技术--代码运行结果与代码执行顺序或调用顺序无关");
        }
    }

**运行结果：**

![20190127133808648.jpg][]

从运行结果，可以知道，代码的运行结果与代码执行顺序或代码调用顺序无关。线程虽然先启动，但是线程的代码确

先执行完。线程调用start方法启动后就会立即返回，并不会等待run方法执行完毕，就好像run方法运行在另外一个cpu

上一样。run方法执行后，打印run方法体中的内容。

使用继承Thread类创建线程的好处就是在Thread类中已经封装了各种方法，方便我们编程。缺点就是在一个已经拥

有父类的类中无法通过继承Thread的方式创建线程，因为java不支持多继承。

## 3、实现Callable接口 ##

实现Callable接口，实现call方法创建线程。

package com.jpeony.concurrent.thread;
    
    import java.util.concurrent.Callable;
    import java.util.concurrent.ExecutionException;
    import java.util.concurrent.FutureTask;
    
    /**
     * 实现Callable，有返回值
     *
     * @author yihonglei
     */
    public class MyCallable implements Callable<String> {
        @Override
        public String call() throws Exception {
            return "test Callable";
        }
    
        public static void main(String[] args) {
            FutureTask<String> futureTask = new FutureTask<>(new MyCallable());
            try {
                new Thread(futureTask).start();
                String s = futureTask.get();
                System.out.println(s);
            } catch (InterruptedException | ExecutionException e) {
                e.printStackTrace();
            }
        }
    }

实现Callable接口创建线程，能拿到线程执行的返回值。

# 三 Thread基本方法 #

## 1、currentThread ##

Thread类中的currentThread()方法，返回当前的线程对象。

package com.jpeony.concurrent.thread;
    
    /**
     * Thread类中的currentThread()方法，返回当前的线程对象
     *
     * @author yihonglei
     */
    public class CurrentThreadMethod extends Thread {
        @Override
        public void run() {
            System.out.println("ThreadName = " + Thread.currentThread().getName());
        }
    
        public static void main(String[] args) {
            CurrentThreadMethod currentThreadMethod = new CurrentThreadMethod();
            currentThreadMethod.start();
        }
    }

## 2、sleep ##

Thread类中的sleep(long millis)方法让当前正在执行的线程休眠指定毫秒数。

package com.jpeony.concurrent.thread;
    
    /**
     * Thread类中的sleep(long millis)方法让当前正在执行的线程休眠指定毫秒数
     *
     * @author yihonglei
     */
    public class SleepMethod extends Thread {
        @Override
        public void run() {
            try {
                System.out.println("ThreadName = " + Thread.currentThread().getName() + " begin time = " + System.currentTimeMillis());
                // 休眠3000毫秒(3秒)
                Thread.sleep(3000);
                System.out.println("ThreadName = " + Thread.currentThread().getName() + " end time = " + System.currentTimeMillis());
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    
        public static void main(String[] args) {
            SleepMethod sleepThread = new SleepMethod();
            sleepThread.start();
        }
    }

## 3、getId ##

获取线程id。

package com.jpeony.concurrent.thread;
    
    /**
     * 获取线程id
     *
     * @author yihonglei
     */
    public class GetIdMethod extends Thread {
        @Override
        public void run() {
            System.out.println("线程ID=" + Thread.currentThread().getId());
        }
    
        public static void main(String[] args) {
            GetIdMethod getIdThread = new GetIdMethod();
            getIdThread.start();
        }
    }

# 四 Thread、Runnable、Callable对比 #

**1、创建线程时是继承Thread还是实现Runnable接口或实现Callable接口？**

哪种方式好并没有一个确定的答案，它们都能满足要求。一般更倾向于实现Runnable接口这种方法。

因为线程池可以有效的管理实现了Runnable接口的线程，如果线程池满了，新的线程就会排队等候执行，

直到线程池空闲出来为止。而如果线程是通过实现Thread子类实现的，这将会复杂一些。

凡事没有绝对，有时我们要同时融合实现Runnable接口和Thread子类两种方式。例如，实现了Thread子类的实例

可以执行多个实现了Runnable接口的线程。一个典型的应用就是线程池。

而Callable几乎没有直接使用的，都是使用扩展类，比如FutureTask等。

**2）调用run()方法还是start()方法启动线程？**

当然是调用start()方法而非run()方法，创建并运行一个线程所犯的常见错误是调用线程的run()方法而非start()方法，

如下所示：

Thread newThread = new Thread(MyRunnable());

newThread.run();  // should be start();

起初你并不会感觉到有什么不妥，因为run()方法的确如你所愿的被调用了。但是，事实上，run()方法并非是由刚创建的

新线程所执行的，而是被创建新线程的当前线程所执行了。也就是被执行上面两行代码的线程所执行的。想要让创建的

新线程执行run()方法，必须调用新线程的start方法。

[https_github.com_yihonglei_jdk-source-code-reading]: https://github.com/yihonglei/jdk-source-code-reading
[20190127133808648.jpg]: /images/20220322/27b3d5c196ff4e85ac296d5b1e5af896.png