Java多线程的三种写法

开发工具与关键技术：MyEclipse 10、Java
作者：曾浩源
撰写时间：2019年05月05日

使用多线程的目的只有一个，那就是为了能更好的利用CPU的资源。所以在Java中也必须有多线程，在学习多线程的过程中认识了三种方法实现多线程。

1.继承Thread这个类，重写run方法。

2.实现Runnable接口，实现run方法。（Thread是Runnable的实现类）

（以上两种方法都 无法抛出异常 不拥有返回值）

3.实现Callable接口，实现call方法。（这个方法可对外抛出异常和拥有返回值）

首先说最简单的第一种方法。

一、继承Thread类

在一个类直接继承Thread，重写run方法，该例子是取钱，每次取1000块，取完跳出循环。

class yinhang1 extends Thread{
     
	private double money=5000;
	@Override
	public void run() {
     
		for (int i = 0; i < money; i++) {
     
			money-=1000;
			System.out.println(Thread.currentThread().getName()+"剩余"+money);
			if (money<=0) {
     
				break;
			}
		}
	}
}
最后在main方法实例化该类，启动线程。（可以为该线程设置名称）
public class Threaddemo2 {
     
	public static void main(String[] args) {
     
		Thread thread1=new yinhang1();
		thread1.setName("工商");
		thread1.start();
	}
}

想要多个线程，只要在线一个类继承Thread，重写run方法，在main方法实例该类，调用该线程。

二、实现Runnable接口，实现run方法。

这里例子也是取钱，但对于上一个例子，这次的钱是共享的。

class yinhang implements Runnable {
     //在类里实现Runnable接口
	private double money = 10000;//有一万元存款
	private double getmoney;//每次取多少
	public yinhang(){
     }//空构造器
	public yinhang(double getmoney){
     
		this.getmoney=getmoney;//每次取多少
	}
	@Override
	public void run() {
     //实现run方法
		for (int i = 0; i < money; i++) {
     
			money -= getmoney;//总存款减去取出金额
			System.out.println(Thread.currentThread().getName()+"取钱后，剩下"+money);
			if (money <= 0) {
     
				break;//跳出循环
			}
		}
	}
}
Main方法：
public class threaddemo {
     
	public static void main(String[] args) {
     
		Runnable yinhang=new yinhang(1000);//设置每次取1000
		Thread xiaoming=new Thread(yinhang,"小明");//实例线程，并命名
		Thread xiaoli=new Thread(yinhang,"小丽");
		Thread xiaogang=new Thread(yinhang,"小刚");
		Thread xiaohong=new Thread(yinhang,"小红");
		xiaoming.start();//启动线程
		xiaoli.start();
		xiaogang.start();
		xiaohong.start();
	}
}

输出结果如右图：

这只是举例有这两种方法，其实Thread也可以实现资源共享，因为Thread本来就是实现了Runnable，包含Runnable的功能是很正常。

（知乎里所说的）两者的真正区别最主要的就是一个是继承，一个是实现；其他还有一些面向对象的思想，Runnable就相当于一个作业，而Thread才是真正的处理线程，我们需要的只是定义这个作业，然后将作业交给线程去处理，这样就达到了松耦合，也符合面向对象里面组合的使用，另外也节省了函数开销，继承Thread的同时，不仅拥有了作业的方法run()，还继承了其他所有的方法。综合来看，用Runnable比Thread好的多。

最后一种：Callable

下面的例子是以直播间的访问人数为例子：

package com.gx.thread;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
public class ZhiBoPingTai {
     
	public static void main(String[] args) throws InterruptedException, ExecutionException {
     
		//设置五个线程
		ExecutorService service=Executors.newFixedThreadPool(5);
		//实例化线程，设置直播间名称，增长人数的速度（如：500毫秒增长1人）
		ZhiBoJian zhiBoJian1=new ZhiBoJian("王者荣耀", 500);
		ZhiBoJian zhiBoJian2=new ZhiBoJian("绝地求生", 300);
		ZhiBoJian zhiBoJian3=new ZhiBoJian("英雄联盟", 50);
		ZhiBoJian zhiBoJian4=new ZhiBoJian("部落冲突", 200);
		ZhiBoJian zhiBoJian5=new ZhiBoJian("美女", 10);
		//Future 相当于是用来存放Executor执行的结果的一种容器  
		Future<Integer> result1=service.submit(zhiBoJian1);
		Future<Integer> result2=service.submit(zhiBoJian2);
		Future<Integer> result3=service.submit(zhiBoJian3);
		Future<Integer> result4=service.submit(zhiBoJian4);
		Future<Integer> result5=service.submit(zhiBoJian5);
		//5秒后线程睡眠
		Thread.sleep(5000);
		//设置各个直播间人数停止增长
		zhiBoJian1.setStop(false);
		zhiBoJian2.setStop(false);
		zhiBoJian3.setStop(false);
		zhiBoJian4.setStop(false);
		zhiBoJian5.setStop(false);
		
		//获取返回值
		int count1=result1.get();
		int count2=result2.get();
		int count3=result3.get();
		int count4=result4.get();
		int count5=result5.get();
		//输出
		System.out.println(zhiBoJian1.getNameString()+"直播间有"+count1+"人");
		System.out.println(zhiBoJian2.getNameString()+"直播间有"+count2+"人");
		System.out.println(zhiBoJian3.getNameString()+"直播间有"+count3+"人");
		System.out.println(zhiBoJian4.getNameString()+"直播间有"+count4+"人");
		System.out.println(zhiBoJian5.getNameString()+"直播间有"+count5+"人");
		
		service.shutdownNow();//现在关闭
	}
}
class ZhiBoJian implements Callable<Integer> {
     
	private String nameString;//直播间名称
	private int peoplenum = 0;//直播间人数
	private boolean stop = true;//手动停止线程
	private long speed;//增长人数的速度

	public ZhiBoJian() {
     }//空构造器

	public ZhiBoJian(String nameString) {
     
		super();
		this.nameString = nameString;
	}
	public ZhiBoJian(String nameString, long speed) {
     
		super();
		this.nameString = nameString;
		this.speed = speed;
	}

	@Override
	public Integer call() throws Exception {
     //实现call方法
		while (stop) {
     
			Thread.sleep(speed);
			peoplenum++;
		}
		return peoplenum;
	}

	public String getNameString() {
     
		return nameString;
	}
	public void setStop(boolean stop) {
     
		this.stop = stop;
	}
}

最后的输出结果是：

Runnable和Callable的区别
(1) Callable规定的方法是 call(), Runnable规定的方法是 run()。
(2) Callable的任务执行后可返回值，而 Runnable的任务是不能返回值。
(3) call方法可以抛出异常， run方法不可以。
(4)运行 Callable任务可以拿到一个 Future对象

在实现接口时，Callable后又对尖括号中间还有个T，如：，这就是泛型，里面尖括号填写你的返回值的类型：
如：

class ZhiBoJian implements Callable<Integer> 

在实现call方法时，返回值的类型也要一样，如：

public Integer call() 它也支持抛出异常 在它后面可以加上 throws Exception