一、java多线程入门类和接口

1、Thread类和Runnable接口

继承Thread类，重写run方法；
实现Runnable接口的run方法；
共同点：

run方法都没有返回值
都是调用start（）方法后，线程启动

比较：

Runnable更灵活
Runnable更符合面向对象
Runnable降低了线程对象和线程任务的耦合性
如果使用线程时不需要使用Thread类的诸多方法，Runnable更轻量

Thread类调用一个私有的init方法来实现初始化，常用方法：

currentThread（）：静态方法，返回当前正在执行的线程对象的引用；
start（）：开始执行线程，开始后调用run（）方法
yield（）：当前线程让出当前处理器的占用，但程序在调度时也可能继续运行这个线程
sleep（）：静态方法，使当前线程睡眠一段时间
join（）：使当前线程等待另一个线程执行完毕后再继续执行（内部调用的是Object类的wait()）

2、Callable、Future、FutureTask

希望线程执行后有返回值，Callable接口和Future类可以做到，这也是所谓的“异步模型”

1、Callable接口

Callable提供的call方法类似于Thread的run方法，只是Callable提供的方法都有返回值，而且支持泛型。Callable一般配合线程池工具ExecutorService来使用，ExecutorService使用submit方法来让Callable接口执行，返回一个Future，后续使用Future的get方法得到结果。
简单使用demo：

class Task implements Callable<Integer>{
	@Override
	public Integer call() throws Exception{
		Thread.sleep(2000);
		return 2;
	}

	public static void main(String args[]){
		ExecutorEservice executor = Executors.newCachedThreadPool();
		Task task = new Task();
		Future<Integer> result = executor.submit(task);
		System.out.println(result.get());
	}
}

输出的结果为2

2、Future接口

Future 接⼝只有⼏个⽐较简单的⽅法：

public abstract interface Future<V> {
 public abstract boolean cancel(boolean paramBoolean);
 public abstract boolean isCancelled();
 public abstract boolean isDone();
 public abstract V get() throws InterruptedException, ExecutionException;
 public abstract V get(long paramLong, TimeUnit paramTimeUnit)
 throws InterruptedException, ExecutionException, TimeoutException;
}

cancel()：试图取消一个线程的执行（因为任务可能已完成、已取消、或者⼀些
其它因素不能取消，存在取消失败的可能。），返回的boolean类型的值就是“是否取消成功的意思”，参数paramBoolean表示是否采用中断的方式取消线程执行。
isCancelled()：判断线程是否取消成功

为了让任务有取消功能，使用Future接口，若想让任务取消又不想返回结果，声明Future

3、FutureTask

FutureTask是Future接口的实现类，其实现了RunnableFuture接口，RunnableFuture接口同时继承了Runnable接口和Future接口：

//一个interface可以继承一个interface，使用extends关键字实现，相当于扩展接口的方法
public interface RunnableFuture<V> extends Runnable, Future<V> {
 /**
 * Sets this Future to the result of its computation
 * unless it has been cancelled.
 */
 void run();
}

为何有FutureTask类：因为Future接口里面的cancel，get，isDone
等方法都需要自己实现，很复杂，所以JDK提供FutureTask类方便使用

// ⾃定义Callable，与上⾯⼀样
class Task implements Callable<Integer>{
 @Override
 public Integer call() throws Exception {
 // 模拟计算需要⼀秒
 Thread.sleep(1000);
 return 2;
 }
 public static void main(String args[]){
 // 使⽤
 ExecutorService executor = Executors.newCachedThreadPool();
 FutureTask<Integer> futureTask = new FutureTask<>(new Task());
 executor.submit(futureTask);
 System.out.println(futureTask.get());
 }
}

使⽤上与第⼀个Demo有⼀点⼩的区别：

这里调⽤ submit ⽅法是没有返回值的。这⾥实际上是调⽤的 submit(Runnable task) ⽅法，⽽上⾯的Demo，调⽤的是 submit(Callable task) ⽅法。
这⾥是使⽤ FutureTask 直接取 get 取值，⽽上⾯的Demo是通过 submit ⽅法返回的 Future 去取值。
在很多⾼并发的环境下，有可能Callable和FutureTask会创建多次。FutureTask能够在⾼并发环境下确保任务只执⾏⼀次。
FutureTask的几个状态：

/**
 *
 * state可能的状态转变路径如下：
 * NEW -> COMPLETING -> NORMAL
 * NEW -> COMPLETING -> EXCEPTIONAL
 * NEW -> CANCELLED
 * NEW -> INTERRUPTING -> INTERRUPTED
 */
private volatile int state;//任务的运行状态
private static final int NEW = 0;//初始状态
private static final int COMPLETING = 1;//任务完成后的瞬时状态
private static final int NORMAL = 2;//任务完成后的瞬时状态
private static final int EXCEPTIONAL = 3;
private static final int CANCELLED = 4;
private static final int INTERRUPTING = 5;
private static final int INTERRUPTED = 6;

运⾏状态只会在set、setException、cancel⽅法中终⽌。

二、线程组合线程优先级

1、线程组

线程组可以对线程进行批量控制，用ThreadGroup表示线程组。每个Thread必然存在于一个ThreadGroup中，如果在new Thread时没有显式指定，那么默认将⽗线程（当前执⾏new Thread的线程）线程组设置为⾃⼰的线程组，例如在main()中new了一个Thread，当前线程组的名字为main。
ThreadGroup管理着它下⾯的Thread，ThreadGroup是⼀个标准的向下引⽤的树状结构，这样设计的原因是防⽌"上级"线程被"下级"线程引⽤⽽⽆法有效地被GC回收。

2、线程的优先级

Java中线程的优先级可以指定，其范围为0-10，但是并不是所有的操作系统都⽀持10级优先级的划分（⽐如有些操作系统只⽀持3级划分：低，中，⾼）。Java只是给操作系统一个优先级的参考值，其最终的优先级还是由操作系统决定。
Java默认的线程优先级为5，线程的执⾏顺序由调度程序来决定，线程的优先级会在线程被调⽤之前设定。
通常情况下，⾼优先级的线程将会⽐低优先级的线程有更⾼的⼏率得到执⾏。使用Thread类的setPriority()和getPriority()来设置和获取优先级。

public class Demo {
 public static void main(String[] args) {
 Thread a = new Thread();
 System.out.println("我是默认线程优先级："+a.getPriority());
 Thread b = new Thread();
 b.setPriority(10);
 System.out.println("我是设置过的线程优先级："+b.getPriority());
 }
}

输出结果：

我是默认线程优先级：5
我是设置过的线程优先级：10

注意：不能采用设定优先级的方法来指定线程执行的先后顺序，其原因上诉说过：Java中的优先级来说不是特别的可靠，Java程序中对线程所设置的优先级只是给操作系统⼀个建议，操作系统不⼀定会采纳。⽽真正的调⽤顺序，是由操作系统的线程调度算法决定的。
验证代码如下：

public class Demo {
 public static class T1 extends Thread {
 @Override
 public void run() {
 super.run();
 System.out.println(String.format("当前执⾏的线程是：%s，优先级：%d",
 Thread.currentThread().getName(),
 Thread.currentThread().getPriority()));
 }
 }
 public static void main(String[] args) {
 IntStream.range(1, 10).forEach(i -> {
 Thread thread = new Thread(new T1());
 thread.setPriority(i);
 thread.start();
 });
 }
}

某次输出结果：

当前执⾏的线程是：Thread-17，优先级：9
当前执⾏的线程是：Thread-1，优先级：1
当前执⾏的线程是：Thread-13，优先级：7
当前执⾏的线程是：Thread-11，优先级：6
当前执⾏的线程是：Thread-15，优先级：8
当前执⾏的线程是：Thread-7，优先级：4
当前执⾏的线程是：Thread-9，优先级：5
当前执⾏的线程是：Thread-3，优先级：2
当前执⾏的线程是：Thread-5，优先级：3

Java提供⼀个线程调度器来监视和控制处于RUNNABLE状态的线程。线程的调度策略采⽤抢占式，优先级⾼的线程⽐优先级低的线程会有更⼤的⼏率优先执⾏。在优先级相同的情况下，按照“先到先得”的原则。每个Java程序都有⼀个默认的主线程，就是通过JVM启动的第⼀个线程main线程。
还有⼀种线程称为守护线程（Daemon），守护线程默认的优先级⽐较低，规则如下：

如果某线程是守护线程，那如果所有的⾮守护线程结束，这个守护线程也会⾃动结束。
当所有⾮守护线程结束时，结束其余的⼦线程（守护线程）⾃动关闭，就免去了还要继续关闭⼦线程的麻烦。
⼀个线程默认是⾮守护线程，可以通过Thread类的setDaemon(boolean on)来设置。
如果某个线程优先级⼤于线程所在线程组的最⼤优先级，那么该线程的优先级将会失效，取⽽代之的是线程组的最⼤优先级。（线程优先级>线程组优先级------>线程优先级失效(优先级为线程组的优先级)）

3、线程组常用方法

一个线程组中除了线程，还可以有其他线程组
获得当前线程组的名字：Thread.currentThread().getThreadGroup().getName()
复制一个线程组到一个新的线程组：

//新建一个线程数组，数组大小为老线程组中活动线程的数量
Thread[] threads = new Thread[threadGroup.activeCount()];
//新建一个线程组
ThreadGroup threadGroup = new ThreadGroup();
//将活动线程的线程组及其子组复制到新的线程组中
threadGroup.enumerate(threads);

线程组统⼀异常处理

package com.func.axc.threadgroup;
public class ThreadGroupDemo {
 public static void main(String[] args) {
 ThreadGroup threadGroup1 = new ThreadGroup("group1") {
 // 继承ThreadGroup并重新定义以下⽅法
 // 在线程成员抛出unchecked exception
 // 会执⾏此⽅法
 public void uncaughtException(Thread t, Throwable e) {
 System.out.println(t.getName() + ": " + e.getMessage());
 }
 };
 // 这个线程是threadGroup1的⼀员
 Thread thread1 = new Thread(threadGroup1, new Runnable() {
 public void run() {
 // 抛出unchecked异常
 throw new RuntimeException("测试异常");
 }
 });
 thread1.start();
 }
}

三、Java线程的状态及主要转化方法

1、操作系统中的线程状态转换

在现在的操作系统中，线程是被视为轻量级进程的，所以操作系统线程的状态其实和操作系统进程的状态是⼀致的。

操作系统线程状态转换图

就绪状态（ready）：线程等待使用CPU，经调度程序调度后可进入running状态
执行状态（running）：线程正在使用CPU
等待状态（waiting）：线程经过等待事件的调用或者正在等待其他资源（如I/O）

2、Java线程的6个状态

getState()方法可以查看该线程的状态

// Thread.State 源码
public enum State {
 NEW,//新建
 RUNNABLE,//运行
 BLOCKED,//阻塞
 WAITING,//等待
 TIMED_WAITING,//超时等待
 TERMINATED;//终止状态
}

1、NEW（新建状态）

处于NEW状态的线程此时尚未启动，这时只是创建了线程，但还没调用start()方法

start()两个问题：

反复调用同一个线程的start方法不可行
假如一个程序执行完毕（处于TERMINATED终止状态），再次调用这个线程的start方法也不可行

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) {
 }
 }
}

查看当前线程状态的源码：

// Thread.getState⽅法源码：
public State getState() {
 // get current thread state
 return sun.misc.VM.toThreadState(threadStatus);
}
// sun.misc.VM 源码：
public static State toThreadState(int var0) {
 if ((var0 & 4) != 0) {
 return State.RUNNABLE;
 } else if ((var0 & 1024) != 0) {
 return State.BLOCKED;
 } else if ((var0 & 16) != 0) {
 return State.WAITING;
 } else if ((var0 & 32) != 0) {
 return State.TIMED_WAITING;
 } else if ((var0 & 2) != 0) {
 return State.TERMINATED;
 } else {
 return (var0 & 1) == 0 ? State.NEW : State.RUNNABLE;
 }
}

源码内部有一个threadStatus变量，如果不等于0就会抛出异常。在调用一次start后，threadStatus的值会改变（不为0），抛出IllegalThreadStateException异常。

2、RUNNABLE（运行状态）

处于RUNNABLE状态的线程在Java虚拟机中运行，也可能在等待其他系统资源（比如I/O）
Java线程的RUNNABLE状态其实包括了操作系统线程的ready和running两个状态

3、BLOCKED（阻塞状态）

处于BLOCKED状态的线程正等待锁的释放以进⼊同步区。
例子：
假如今天你下班后准备去⻝堂吃饭。你来到⻝堂仅有的⼀个窗⼝，发现前⾯已经有个⼈在窗⼝前了，此时你必须得等前⾯的⼈从窗⼝离开才⾏。假设你是线程t2，你前⾯的那个⼈是线程t1。此时t1占有了锁（⻝堂唯⼀的
窗⼝），t2正在等待锁的释放，所以此时t2就处于BLOCKED状态。

4、WAITING（等待状态）

处于等待状态的线程变成RUNNABLE状态需要其他线程唤醒。
使线程进入等待状态的方法：

Object.wait()：使当前线程处于等待状态直到另一个线程唤醒它
Thread.join()：等待线程执行完毕，底层调用的是Object实例的wait方法
LockSupport.park()：除非获得调用许可，否则禁用当前线程进行线程调度

延续上⾯的例⼦：
你等了好⼏分钟现在终于轮到你了，突然你们有⼀个“不懂事”的经理突然来了。你看到他你就有⼀种不祥的预感，果然，他是来找你的。
他把你拉到⼀旁叫你待会⼉再吃饭，说他下午要去作报告，赶紧来找你了解⼀下项⽬的情况。你⼼⾥虽然有⼀万个不愿意但是你还是从⻝堂窗⼝⾛开了。
此时，假设你还是线程t2，你的经理是线程t1。虽然你此时都占有锁（窗⼝）了，“不速之客”来了你还是得释放掉锁。此时你t2的状态就是WAITING。然后经理t1获得锁，进⼊RUNNABLE状态。要是经理t1不主动唤醒你t2（notify、notifyAll…），可以说你t2只能⼀直等待了。

5、TIMED_WAITING（超时等待状态）

线程等待⼀个具体的时间，时间到后会被⾃动唤醒。
调用以下方法会使线程进入超时等待状态：

Thread.sleep(long millis)：使当前线程睡眠指定的时间
Object.wait(long timeout)：线程休眠指定时间，等待期间可以通过notify()/notifyAll()唤醒
Thread.join(long millis)：等待当前线程最多执⾏millis毫秒，如果millis为0，则会⼀直执⾏
LockSupport.parkNanos(long nanos)：除⾮获得调⽤许可，否则禁⽤当前线程进⾏线程调度指定时间
LockSupport.parkUntil(long deadline)：同上，也是禁⽌线程进⾏调度指定时间
续延续上⾯的例⼦：
到了第⼆天中午，⼜到了饭点，你还是到了窗⼝前。突然间想起你的同事叫你等他⼀起，他说让你等他⼗分钟他改个bug。好吧，你说那你就等等吧，你就离开了窗⼝。很快⼗分钟过去了，你⻅他还没来，你想都等了这么久了还不来，那你还是先去吃饭好了。
这时你还是线程t1，你改bug的同事是线程t2。t2让t1等待了指定时间，t1先主动释放了锁。此时t1等待期间就属于TIMED_WATING状态。t1等待10分钟后，就⾃动唤醒，拥有了去争夺锁的资格。

6、TERMINATED（终止状态）

这时的状态已经执行完毕了

3、线程状态的转换

如下是线程状态转换图：

线程中断：在线程启动后发现并不需要它继续执行下去时，需要中断线程。
⽬前在Java⾥还没有安全直接的⽅法来停⽌线程，但是Java提供了线程中断机制来处理需要中断线程的情况。
线程中断机制是⼀种协作机制。需要注意，通过中断操作并不能直接终⽌⼀个线程，⽽是通知需要被中断的线程⾃⾏处理。
关于线程中断的几个方法：

Thread.interrupt()：中断线程。这⾥的中断线程并不会⽴即停⽌线程，⽽是设置线程的中断状态为true（默认是flase）
Thread.interrupted()：测试当前线程是否被中断。线程的中断状态受这个⽅法的影响，意思是调⽤⼀次使线程中断状态设置为true，连续调⽤两次会使得这个线程的中断状态重新转为false
Thread.isInterrupted()：测试当前线程是否被中断。与上⾯⽅法不同的是调⽤这个⽅法并不会影响线程的中断状态
在线程中断机制⾥，当其他线程通知需要被中断的线程后，线程中断的状态被设置为true，但是具体被要求中断的线程要怎么处理，完全由被中断线程⾃⼰⽽定，可以在合适的实际处理中断请求，也可以完全不处理继续执⾏下去

四、Java线程件的通信

⼀般来讲，线程内部有⾃⼰私有的线程上下⽂，互不⼲扰，但当我们需要多个线程之间相互协作的时候，就需要我们掌握Java线程的通信⽅式

1、锁与同步

在Java中，锁的概念都是基于对象的，所以我们⼜经常称它为对象锁。线程和锁的关系，我们可以⽤婚姻关系来理解。⼀个锁同⼀时间只能被⼀个线程持有。也就是说，⼀个锁如果和⼀个线程“结婚”（持有），那其他线程如果需要得到这个锁，就得等这个线程和这个锁“离婚”（释放）。
在我们的线程之间，有⼀个同步的概念。什么是同步呢，假如我们现在有2位正在抄暑假作业答案的同学：线程A和线程B。当他们正在抄的时候，⽼师突然来修改了⼀些答案，可能A和B最后写出的暑假作业就不⼀样。我们为了A,B能写出2本相同的暑假作业，我们就需要让⽼师先修改答案，然后A，B同学再抄。或者A，B同
学先抄完，⽼师再修改答案。这就是线程A，线程B的线程同步。
可以以解释为：线程同步是线程之间按照⼀定的顺序执⾏。
为了达到线程同步，我们可以使⽤锁来实现它。

我想等线程A先执⾏完之后，再由线程B去执⾏，最简单的⽅式就是使⽤⼀个“对象锁”：

public class ObjectLock {
	 private static Object lock = new Object();//声明对象锁
	 static class ThreadA implements Runnable {
 		@Override
 		public void run() {
 			synchronized (lock) {//加锁
 			for (int i = 0; i < 100; i++) {
 				System.out.println("Thread A " + i);
 			}
 			}
 		}
 	}
	static class ThreadB implements Runnable {
 		@Override
 		public void run() {
 			synchronized (lock) {//加锁
 				for (int i = 0; i < 100; i++) {
 					System.out.println("Thread B " + i);
 				}
 			}
 		}
 	}
	public static void main(String[] args) throws InterruptedException {
 		new Thread(new ThreadA()).start();
		Thread.sleep(10);//防止B线程先得到锁
 		new Thread(new ThreadB()).start();
 	}
}

这⾥声明了⼀个名字为 lock 的对象锁。我们在 ThreadA 和 ThreadB 内需要同步的代码块⾥，都是⽤ synchronized 关键字加上了同⼀个对象锁 lock 。

2、等待/通知机制

上⾯⼀种基于“锁”的⽅式，线程需要不断地去尝试获得锁，如果失败了，再继续尝试。这可能会耗费服务器资源。
Java多线程的等待/通知机制是基于 Object 类的 wait() ⽅法和 notify() ,notifyAll() ⽅法来实现的。
notify()⽅法会随机叫醒⼀个正在等待的线程，⽽notifyAll()会叫醒所有正在等待的线程。
前⾯我们讲到，⼀个锁同⼀时刻只能被⼀个线程持有。⽽假如线程A现在持有了⼀个锁 lock 并开始执⾏，它可以使⽤ lock.wait() 让⾃⼰进⼊等待状态。这个时候， lock 这个锁是被释放了的。
这时，线程B获得了 lock 这个锁并开始执⾏，它可以在某⼀时刻，使⽤ lock.notify() ，通知之前持有 lock 锁并进⼊等待状态的线程A，说“线程A你不⽤等了，可以往下执⾏了”。
需要注意的是等待/通知机制使⽤的是使⽤同⼀个对象锁，如果你两个线程使⽤的是不同的对象锁，那它们之间是不能⽤等待/通知机制通信的。

3、信号量

volitile关键字能够保证内存的可⻅性，如果⽤volitile关键字声明了⼀个变量，在⼀个线程⾥⾯改变了这个变量的值，那其它线程是⽴⻢可⻅更改后的值的。

java java 开发语言

Java多线程

文章目录