Java多线程实现

╰半夏微凉° 2022-05-21 04:05 247阅读 0赞

Java中三种多线程的实现方式。

如果要想在Java中实现多线程有两种途径：

·继承Thread类；

·实现Runnable接口（Callable接口）；

**继承Thread类**

package thread;
 //线程操作主类
 class MyThread extends Thread//这是一个多线程的操作类
 {
 	private String name ;
 	public MyThread(String name)
 	{
 		this.name = name;
 	}
 	@Override
 	public void run() {//覆写run()方法，作为线程的主体操作方法
 		for(int x = 1 ; x < 51 ; x++)
 		{
 			System.out.println(this.name + "-->"+x);
 		}
 	}
 }
 public class ThreadTest 
 {
 	public static void main(String[] args) 
 	{
 		MyThread mt1 = new MyThread("线程A");
 		MyThread mt2 = new MyThread("线程B");
 		MyThread mt3 = new MyThread("线程C");
 		
 		mt1.start();
 		mt2.start();
 		mt3.start();
 	}
 }

结果

线程A-->42
    线程A-->43
    线程A-->44
    线程A-->45
    线程A-->46
    线程B-->1
    线程A-->47
    线程B-->2
    线程A-->48
    线程B-->3
    线程A-->49
    线程B-->4
    线程C-->1
    线程C-->2
    线程A-->50
    线程C-->3
    线程C-->4
    线程C-->5

**疑问？为什么多线程启动不是调用run()方法而是调用start()方法？**

看下strat方法定义

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

发现在strat方法里面调用了start0()方法，与抽象方法类似，但是使用了native声明。在Java里有JNI技术（Java Native Interface），特点：使用Java调用本机操作系统提供的函数。缺点是不能够离开特定的操作系统。

如果要想线程能够执行，需要操作系统来进行资源分配，所以操作严格来讲主要是由JVM负责根据不同的操作系统而实现的 。

即：使用Thread类的start（）方法不仅仅要启动多线程的执行代码，还要去根据不同的操作系统进行资源的分配。

**实现Runnable接口**

package thread;
 class MyThread implements Runnable//这是一个多线程的操作类
 {
 	private String name ;
 	public MyThread(String name)
 	{
 		this.name = name;
 	}
 	@Override
 	public void run() {//覆写run()方法，作为线程的主体操作方法
 		for(int x = 1 ; x < 51 ; x++)
 		{
 			System.out.println(this.name + "-->"+x);
 		}
 	}
 }
 public class ThreadTest 
 {
 	public static void main(String[] args) 
 	{
 		MyThread mt1 = new MyThread("线程A");
 		MyThread mt2 = new MyThread("线程B");
 		MyThread mt3 = new MyThread("线程C");
 		
 		new Thread(mt1).start();
 		new Thread(mt2).start();
 		new Thread(mt3).start();
 	}
 }

## （面试题）多线程两种实现方式的区别？ ##

·使用**Runnable****接口**与**Thread****类**相比，解决了单继承的定义局限！

·Runnable接口实现的多线程可以比Thread类实现的多线程更加清楚的描述共享的概念。

<table> 
 <tbody> 
 <tr> 
 <td style="vertical-align:top;width:426.1pt;"> public class Thread extends Object implements Runnable </td> 
 </tr> 
 <tr> 
 <td style="vertical-align:top;width:426.1pt;"> @FunctionalInterface public interface Runnable { &nbsp;&nbsp;&nbsp; public abstract void run(); } </td> 
 </tr> 
 </tbody> 
</table>

![70][]

第三种实现方法：

Runnable接口实现多线程，其中的Run（）方法不能返回结果，为了解决这样的矛盾，提供了一个新的接口Callable接口。

# **Callable接口** #

<table> 
 <tbody> 
 <tr> 
 <td style="vertical-align:top;width:426.1pt;"> Package java.util.concurrent Interface Callable&lt;V&gt; </td> 
 </tr> 
 <tr> 
 <td style="vertical-align:top;width:426.1pt;"> @FunctionalInterface public interface Callable&lt;V&gt; { &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; V call() throws Exception; } </td> 
 </tr> 
 <tr> 
 <td style="vertical-align:top;width:426.1pt;"> java.util.concurrent Interface Future&lt;V&gt; </td> 
 </tr> 
 <tr> 
 <td style="vertical-align:top;width:426.1pt;"> java.util.concurrent.FutureTask&lt;V&gt; public class FutureTask&lt;V&gt; extends Object implements RunnableFuture&lt;V&gt; </td> 
 </tr> 
 <tr> 
 <td style="vertical-align:top;width:426.1pt;"> public interface RunnableFuture&lt;V&gt; extends Runnable, Future&lt;V&gt; </td> 
 </tr> 
 </tbody> 
</table>

![70 1][]

package thread;
 import java.util.concurrent.Callable;
 import java.util.concurrent.FutureTask;
 /**
 * 使用Callable实现多线程
 * 2017-10-07
 * @author Junwei Zhu
 *
 */
 class MyThread02 implements Callable<String>{
 	private int ticket = 10 ;
 	@Override
 	public String call() throws Exception {
 		for(int x = 0 ; x < 100 ; x ++)
 		{
 			if(this.ticket>0)
 				System.out.println("卖票，ticket:"+this.ticket--);
 		}
 		return "票已卖光。" ;
 	}
 	
 }
 public class CallableTest {
 	public static void main(String[] args) throws Exception {
 		MyThread02 mt1 = new MyThread02();
 		MyThread02 mt2 = new MyThread02();
 		//目的是取得call()返回结果
 		FutureTask<String> task1 = new FutureTask<String>(mt1);
 		FutureTask<String> task2 = new FutureTask<String>(mt2);
 		//FutureTask是Runnable接口子类，所以可以使用Thread类的构造来接收task对象
 		new Thread(task1).start();//启动多线程
 		new Thread(task2).start();
 		//多线程执行完毕后可以取得内容，依靠FutureTask中的Future中的get()方法完成
 		System.out.println("A线程的返回结果："+task1.get());
 		System.out.println("B线程的返回结果："+task2.get());
 	}
 }

结果：

卖票，ticket:10
    卖票，ticket:9
    卖票，ticket:8
    卖票，ticket:8
    卖票，ticket:7
    卖票，ticket:6
    卖票，ticket:7
    卖票，ticket:5
    卖票，ticket:6
    卖票，ticket:5
    卖票，ticket:4
    卖票，ticket:4
    卖票，ticket:3
    卖票，ticket:3
    卖票，ticket:2
    卖票，ticket:1
    卖票，ticket:2
    A线程的返回结果：票已卖光。
    卖票，ticket:1
    B线程的返回结果：票已卖光。

[70]: /images/20220521/4bdc01d1e0fb4ed0aaf0e3272343a27b.png
[70 1]: /images/20220521/11cb28b211c646448ba38a8d42660556.png