java多线程实现

最新推荐文章于 2020-02-29 19:21:20 发布

pinazhang

最新推荐文章于 2020-02-29 19:21:20 发布

阅读量172

点赞数

分类专栏： Java基础文章标签： java 实现多线程

本文链接：https://blog.csdn.net/weixin_41550144/article/details/87884785

版权

Java基础专栏收录该内容

41 篇文章 0 订阅

订阅专栏

实现多线程的前提：有一个线程的执行主类。（与main()函数类似，是线程启动的入口。）

如果现在要想实现一个多线程的主类，有两个途径：
1. 继承一个Thread类；（有单继承局限）
2. 【推荐】实现Runnable、Callable接口。

本篇的总结：无论是用Thread类、Runnable接口还是Callable接口，其实都是去找多线程的启动方法（start()方法）去启动多线程。

一、Thread类实现多线程

java.lang.Thread是一个线程操作的核心类。定义一个线程的主类，最简单的方法就是直接继承Thread类，然后覆写该类中的run()方法（相当于线程的主方法）。

但是不能直接调用run()方法（只调用run()方法的话，就相当于对每个线程分别进行了顺序打印，不会出现线程的交替执行），正确启动多线程的方式应该是调用Thread类中的start()方法，通过start()方法调用run()方法(见下图)
在这里插入图片描述
启动多线程：public void start();调用此方法会调用run()方法。

代码示例：

package cn.edu.www;

class MyThread extends Thread{//是一个线程主题类
	private String title;
	public MyThread(String title) {
		this.title=title;
	}
	@Override
	public void run() {
		for (int x=0;x<6;x++) {
			System.out.println(this.title+": x="+x);
		}
	}
}
public class TestDemo {
	public static void main(String[] args) {
		MyThread p1=new MyThread("线程A");
		MyThread p2=new MyThread("线程B");
		MyThread p3=new MyThread("线程C");
		p1.start();
		p2.start();
		p3.start();
		}
}

运行结果：（三个线程是交替执行的，而不是各自执行各自的。每运行一次，结果会不同）

线程B: x=0
线程A: x=0
线程C: x=0
线程A: x=1
线程B: x=1
线程B: x=2
线程B: x=3
线程B: x=4
线程B: x=5
线程A: x=2
线程C: x=1
线程C: x=2
线程C: x=3
线程C: x=4
线程C: x=5
线程A: x=3
线程A: x=4
线程A: x=5

问题：为什么要通过start()方法调用run()方法呢？
从java的源代码（在JDK的安装目录下->src.zip->java->lang->Thread.java）中找答案。
代码很多，直接看关于start()方法的源代码如下：

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

解释源代码：
1. 异常的抛出：IllegalThreadStateException，此异常是一个RuntimeException的子类。（当重复启动了多线程时就会出现此异常）
2. 最后一行是一个start0()方法，是一个只声明未实现的方法，并且用关键字native进行定义，native指的是调用本机的原生系统函数。这个方法是由不同操作系统版本的JVM实现。所以native在该情况下指的就是该操作将交由本地操作系统进行支持。这就是为什么通过start()调用run()方法的原因。

二、使用Runnable接口实现多线程

Thread类的核心功能是进行线程的启动，但是Thread类具有单继承局限，所以java提供了另外一种实现模式：Runnable接口。

在JDK文档中查找Runnable接口定义：该接口是一个函数式接口，只存在一个run()方法。

@FunctionalInterface
public interface Runnable{
	public void run();
}

虽然解决了单继承问题，但是没有了start()方法被继承了。那么此时就需要关注Thread类提供的构造方法，以此找到可以使用start()方法的途径，得以启动多线程：

构造方法：public Thread(Runnable target)，可以接收Runnable接口对象，就意味着可以通过Thread类启动多线程。

代码示例：用Runnable接口启动多线程

class MyThread implements Runnable{//是一个线程主题类
	private String title;
	public MyThread(String title) {
		this.title=title;
	}
	@Override
	public void run() {
		for (int x=0;x<6;x++) {
			System.out.println(this.title+": x="+x);
		}
	}
}
public class TestDemo {
	public static void main(String[] args) {
		MyThread p1=new MyThread("线程A");
		MyThread p2=new MyThread("线程B");
		MyThread p3=new MyThread("线程C");
		new Thread(p1).start();//应用Thread的构造方法，启动多线程
		new Thread(p2).start();
		new Thread(p3).start();
		}
}

运行结果：

线程B: x=0
线程B: x=1
线程B: x=2
线程B: x=3
线程B: x=4
线程B: x=5
线程A: x=0
线程A: x=1
线程A: x=2
线程C: x=0
线程C: x=1
线程C: x=2
线程A: x=3
线程C: x=3
线程C: x=4
线程C: x=5
线程A: x=4
线程A: x=5

由以上代码可以知道，多线程的启动永远都是Thread类的start()方法!!!

注：对于Runnable接口对象也可以采用匿名内部类或者Lambda表达式类进行定义。

代码示例1：匿名内部类

public class TestDemo {
	public static void main(String[] args) {
		new Thread(new Runnable() {
			@Override
			public void run() {
				System.out.println("hello!");				
			}
		}).start();
		}
}

代码示例2：Lambda表达式

public class TestDemo {
	public static void main(String[] args) {
		new Thread(()->System.out.println("hello!")).start();
		}
}

三、Thread与Runnable的区别

使用形式上：使用Runnable实现多线程会更好，因为避免了单继承的局限。
除此之外，Thread和Runnable之间存在着一些联系。观察Thread类的定义形式：（JDK文档）

public class Thread extends Object implements Runnable

Thread类是Runnable接口的子类，所以Thread类覆写了run()方法。
Thread类覆写run()方法的源代码：

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


public Thread(Runnable target) {
        init(null, target, "Thread-" + nextThreadNum(), 0);
    }

private Runnable target;

所以结合之前的程序代码就可以形成如下的类继承结构：
在这里插入图片描述

所以在多线程的处理上使用的就是代理设计模式!!!

四、线程的运行状态（面试题）

线程的启动使用的是start()方法，但是并不意味着调用了start()方法就立刻调用多线程。

在这里插入图片描述

当多线程调用了start()方法之后并不是立刻执行，而是进入到就绪状态，等待进行调度后执行，当分配到资源后，才可以执行多线程的代码（run()中的代码），当执行了一段时间之后，就要让出资源，让其他线程继续执行，也就是说run()方法可能还没执行完，只执行了一部分，就要让出资源，重新进入就绪状态，重新等待分配新资源再继续执行。当线程执行完毕后才会进入到终止状态。

五、Callable实现多线程

在JDK1.5之后追加了一个新的开发包：java.util.concurrent，这个开发包主要是进行高性能编程使用的，也就是在这个开发包中会提供一些高并发操作中才会使用到的类。这个包中定义有一个新的接口：

@FunctionalInterface
public interface Callable<V>{
	public V call() throws Exception;
}

注意：Runnable接口中的run()方法是线程的主方法，可以启动线程，那么和Callable接口中的call()方法有什么区别呢？
答：Runnable接口中的run()方法没有返回值，而Callable接口中的call()方法是有返回值的。

但是只有Thread类中的start()方法可以启动多线程。首先了分析一下Callable接口的定义：
在这里插入图片描述

代码示例：使用Callable启动多线程的方法

import java.util.concurrent.Callable;

class MyThread implements Callable<String>{
	@Override
	public String call() throws Exception {
		for (int x=0;x<10;x++) {
			System.out.println("cat="+x);
		}
		return "猫";
	}
}
public class TestDemo {
	public static void main(String[] args) throws Exception{
		FutureTask<String> task=new FutureTask<String>(new MyThread());
		new Thread(task).start();
		System.out.println(task.get());
		}
}

运行结果：

cat=0
cat=1
cat=2
cat=3
cat=4
cat=5
cat=6
cat=7
cat=8
cat=9
猫

pinazhang

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
2
评论
java多线程实现

实现多线程的前提：有一个线程的执行主类。（与main()函数类似，是线程启动的入口。）如果现在要想实现一个多线程的主类，有两个途径：1. 继承一个Thread类；（有单继承局限）2. 【推荐】实现Runnable、Callable接口。本篇的总结：无论是用Thread类、Runnable接口还是Callable接口，其实都是去找多线程的启动方法（start()方法）去启动多线程。一、Th...
复制链接

扫一扫