Java多线程实现

快来打我* 2021-09-30 05:06 373阅读 0赞

# 概述： #

共有三种实现方法：**（1）继承Thread类；（2）实现Runnable接口；（3）实现Callable接口**(此方法为JDK1.5增加的方法)。  
实际开发中主要使用接口定义的线程类，即方法（2）与方法（3）。

# 1、继承Thread类： #

java.lang.Thread 是一个负责线程操作的类，任何类只需继承 Thread 类就能够成为一个线程的**主类**。主类必须有它的使用方法，线程启动的主方法需要覆写 Thread 类中的** run() **方法实现。线程主体类的定义格式如下：

class 类名称 extends Thread{
        属性...;
        方法...;
        
        @Override
        public void run(){
            线程的主体方法；
        }
    }

所有的线程与进程都是通过轮流抢占资源实现对应程序部分的运行，因此多线程的执行应该是多个线程彼此交替执行。直接调用 run() 方法，并不能启动多线程，多线程启动的唯一方法是调用 Thread 中的 start() 方法：public void start()。

示例1：

//通过继承Thread类，实现一个多线程操作类
    class MyThread extends Thread{  
    	private String name;  // 类名称
    	public MyThread(String name) {	// 定义构造方法
    		this.name = name;
    	}
    	@Override
    	public void run() {
    		for(int i=0; i<100; i++) {
    			System.out.println(this.name + "--" + i);
    		}
    	}
    }
    
    // 启动多线程
    public class ThreadDemo {
    	public static void main(String[] args) {
    		// 实例化多线程对象
    		MyThread thread1 = new MyThread("A线程");
    		MyThread thread2 = new MyThread("B线程");
    		MyThread thread3 = new MyThread("C线程");
    		// 启动多线程
    		thread1.start();
    		thread2.start();
    		thread3.start();
    	}
    }

使用 Thread类 实现多线程存在一个缺点：单继承问题。

# 2、实现Runnable接口： #

Runnable 接口定义：

![20190725194340855.png][]

要启动多线程，必须通过 Thread类 中的 start() 方法。但是，因为 Runnable 接口没有提供可以被继承的 Start() 方法，所以需要其他途径实现。

![201907252005449.png][]

Thread 类中提供了一个有参构造方法，如上图。本方法可以接收一个 Runnable 接口对象。示例如下：

// 定义线程主题类
    class RunnableThread implements Runnable{
    	private String name;
    	public RunnableThread(String name) {
    		this.name = name;
    	}
    
    	@Override
    	public void run() {
    		for(int x=0; x<100; x++) {
    			System.out.println(this.name + "--" + x);
    		}
    	}
    }
    // 利用 Thread 启动多线程 
    public class RunnableDemo {
    	public static void main(String[] args) {
    		// 实例化多线程类对象
    		RunnableThread run1 = new RunnableThread("A线程");
    		RunnableThread run2 = new RunnableThread("B线程");
    		RunnableThread run3 = new RunnableThread("C线程");
    		// 利用Thread启动多线程
    		new Thread(run1).start();   // 等价实现 Thread r1 = new Thread(run1); r1.start();
    		new Thread(run2).start();
    		new Thread(run3).start();
    	}
    }

其实，我们查看 Thread类 的源码可以发现，Thread类 实现了 Runnable 接口，即 Thread类 是Runnable 接口的子类：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI3Mzc4NjIx_size_16_color_FFFFFF_t_70][]

## 对比：  ##

*  以上两种方式都需要一个线程的主类，这个类可以实现 Runnable 接口或者继承 Thread 类，无论使用哪种方式都需要在子类中覆写 run() 方法，此方法为线程的主方法；
 *  Thread类 是 Runnable接口 的子类，而使用 Runnable接口 可以避免单继承局限，并可以更加方便地体现现数据共享的概念。

# 三、实现Callable接口： #

问题的引出：Runnable接口 里面的run() 方法不能返回操作结果。从 JDK1.5 开始，Java 提供了一个新的支持多线程实现的接口：java.util.concurrent.Callable，定义如下：![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI3Mzc4NjIx_size_16_color_FFFFFF_t_70 1][]

##  新的问题的出现： ##

多线程的主体定义完成后，需要利用 Thread 类 启动多线程。但在 Thread  类中没有定义任何构造方法可以直接接收 Callable 接口对象实例，并且由于需要接收 Call() 方法返回值的问题，于是 从JDK1.5 开始，Java 同时提供了一个 java.util.concurrent.FutureTask<V> 类：

![20190725213604903.png][]

通过上图，可以看出 FutureTask类 实现了 RunnableFuture接口，而 RunnableFuture 接口又实现了 **Future 与 Runnable** 接口。故 FutureTask类 是 Runnable接口 的子类，因此其可以利用 Thread类 来实现多线程的启动。

## FutureTask类常用方法： ##

<table>  FutureTask类常用方法  
 <tbody> 
  <tr> 
   <td>No</td> 
   <td style="width:324px;">方法</td> 
   <td style="width:70px;">类型</td> 
   <td style="width:316px;">描述</td> 
  </tr> 
  <tr> 
   <td>1</td> 
   <td style="width:324px;">public&nbsp;FutureTask(Callable&lt;V&gt; callable)</td> 
   <td style="width:70px;">构造</td> 
   <td style="width:316px;">接收Callable接口实例</td> 
  </tr> 
  <tr> 
   <td>2</td> 
   <td style="width:324px;">public&nbsp;FutureTask(Runnable runnable, V result)</td> 
   <td style="width:70px;">构造</td> 
   <td style="width:316px;">接收Runnable接口实例，并制定返回值的类型</td> 
  </tr> 
  <tr> 
   <td>3</td> 
   <td style="width:324px;">public V get() throws Interrupted Exception, ExecutionException</td> 
   <td style="width:70px;">普通</td> 
   <td style="width:316px;">取得线程操作结果，此方法为 Future接口 定义</td> 
  </tr> 
 </tbody> 
</table>

可见，FutureTask类 可以接收 Callable接口 实例 ，如果想要接收返回结果，使用 get() 方法即可。

## 实现多线程代码示例： ##

import java.util.concurrent.Callable;
    import java.util.concurrent.FutureTask;
    
    class CallableThread implements Callable<String>{
    	private String name;
    	private int tickets = 10;
    	public CallableThread(String name) {
    		this.name = name;
    	}
    	@Override
    	public String call() throws Exception {
    		for(int i=0; i<100; i++) {
    			if(this.tickets > 0) {
    				System.out.println(this.name + "剩余，tickets = " + this.tickets--);
    			}
    		}
    		return "票已全部售出。";
    	}
    } 
    
    public class CallableDemo {
    	public static void main(String[] args) throws Exception{
    		CallableThread thread1 = new CallableThread("thread1");  // 实例化多线程对象
    		CallableThread thread2 = new CallableThread("thread2");  // 实例化多线程对象
    		CallableThread thread3 = new CallableThread("thread3");  // 实例化多线程对象
    		
    		FutureTask<String> task1 =  new FutureTask<String>(thread1);
    		FutureTask<String> task2 =  new FutureTask<String>(thread2);
    		FutureTask<String> task3 =  new FutureTask<String>(thread3);
    		// FutureTask 是 Runnable 接口的子类，所以可以使用Thread类的构造来接收 task 对象；
    		new Thread(task1).start();
    		new Thread(task2).start();
    		new Thread(task3).start();
    		// 依靠Futuretask的父类接口Future中的get() 方法实现
    		System.out.println("线程1的返回结果"+task1.get());
    		System.out.println("线程2的返回结果"+task2.get());
    		System.out.println("线程3的返回结果"+task3.get());
    	}
    }

[20190725194340855.png]: /images/20210920/abc36f6ba63c4ca0bef1a2ec6454fc3a.png
[201907252005449.png]: /images/20210920/e14c34761cdb4f9bb14ac1b19ca583fb.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI3Mzc4NjIx_size_16_color_FFFFFF_t_70]: /images/20210920/930d1455ecb74a9ba5e33cfb9963a22a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI3Mzc4NjIx_size_16_color_FFFFFF_t_70 1]: /images/20210920/d5bcf8c397a541cf80cc3c64d7be32bf.png
[20190725213604903.png]: /images/20210920/6a5710061e1a49acaadcdead0ab9499b.png