【Java】多线程并发基础——细节决定成败

已于 2022-11-10 00:10:04 修改
阅读量971 收藏 50
点赞数 26
分类专栏： # Java SE 文章标签： 多线程 java
于 2020-03-26 23:07:42 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42470947/article/details/104622945
版权

目录

进程与线程

多线程技术原理

1. CPU切片

2. CPU多核处理

3. 合理利用CPU资源

JVM中的多线程与垃圾回收

创建线程的二中方式

1. 继承Thread类创建线程

2. 实现Runnable接口创建线程

3. 实现Runnable接口的好处

调用start()和run()的区别

多线程内存图（简）

多线程的运行状态

多线程同步

1. 多线程卖票产生的问题

2. 同步代码块

2.1 synchronized ( Lock ) { code... }

2.2 双重判断-解决

3. 同步函数

3.1 锁的作用域

3.2 验证非静态同步函数使用 this 锁

3.3 验证静态同步函数使用 类.class 锁

4. 同步代码块与同步函数的区别

5. 同步好处与弊端

6. 练习：单列模式并发访问（性能对比）

死锁

场景一：同步嵌套

多线程间的通信

1. 线程等待唤醒机制

线程池

2. 多生产多消费例子

JDK1.4版本前多生产与消费唤醒机制效率问题

3. JDK1.5版本Lock接口

3.1 JDK1.5版本Condition接口

3.2 使用Lock接口的好处

4. 多生产多消费效率解决

wait()和sleep()的区别

异常信息在多线程中的阅读

线程优先级

join()方法

守护线程

线程停止

进程与线程

  • 进程：应用程序在内存中分配的空间。（正在运行中的程序）
  • 线程：负责程序执行的单元，也称为执行路径。（需要线程来执行代码）。一个进程至少包含一条线程，如果一个进程中出现了条线程，此程序就为多线程程序。

多线程技术原理

多线程解决多部分代码同时执行的需求。

1. CPU切片

1、CPU在某一时间段只能执行一条线程，我们看到的程序以为都是在同时执行的（其实并不是同时执行），2、只不过是CPU在高速的切换执行的线程（切换的时间是仅仅是几~ms），3、CPU切换的线程并不是有序的（根据某种规则算法（如线程优先级）算出最需要执行的线程，所以CPU切换执行的线程是随机性的）4、线程的执行时间段根据CPU算法而定。

2. CPU多核处理

早期的CPU一个时间段只能执行一条线程（这是因为只有一个核心），早期的服务器装的CPU直接装的几个。后来为了解决发热问题也就使用了纳米技术缩小CPU里的晶体管，之后就集成了多核CPU，根据CPU的每个核心就能同时处理多条线程。但是一个进程中的多条线程是不会出现在不同CPU核心的，也就是一个进程中的多线程只能被一个CPU核心处理。

3. 合理利用CPU资源

线程开多了并不会真正的提高程序的效率，会降低每条线程能被执行到的时间、线程被执行的时间段、线程被执行的几率，以及可能会出现卡顿现象。所以请合理利用CPU资源开启多线程。

JVM中的多线程与垃圾回收

JVM有自己的线程，有多条以上，我们现在关注的有：一条是程序运行的Main线程，一条是垃圾回收线程（根据垃圾回收器的不同可能有多条垃圾回收线程并发执行）。

对象的回收 :

所有对象都具备被回收前的回调方法，此方法由程序员在自定义类时，垃圾回收前检查此类的相关资源是否关闭等清除操作...。

Object类的finalize()方法

测试：

package com.bin.demo;

import java.util.ArrayList;

class Demo {
	@Override
	protected void finalize() throws Throwable {
		System.out.println("已回收");
	}
}

public class Main {

	public static void main(String[] args) throws InterruptedException {

		ArrayList<Demo> list = new ArrayList<Demo>();
		for (int i = 0; i < 5; i++) {
			list.add(new Demo());
		}
//		list = null;
		list.clear(); //释放强引用
		System.gc(); //手动启动垃圾回收器
		System.out.println("Main线程执行完毕");

	}

}

输出：

已回收
Main线程执行完毕
已回收
已回收
已回收
已回收

System.gc();启动垃圾回收器线程，执不执行CPU说了算。

可见，垃圾回收器线程回收了一个对象后，CPU立马切换到了Main线程，再切换到垃圾回收器线程回收对象。

由此可见，CPU切换执行的线程是随机性的。

创建线程的二中方式

1. 继承Thread类创建线程

继承Thread类，并重写run()方法，创建Thread对象，调用start()方法开启线程。

package com.bin.demo;

class Demo extends Thread {
	
	private String name;
	
	Demo(String name) {
		this.name = name;
	}
	
	@Override
	public void run() {
		for (int i = 0; i < 5; i++) { //获取线程名
			System.out.println(getName() + " ————> " + name);
		}
	}
}

public class Main {

	public static void main(String[] args) throws InterruptedException {

		//创建线程对象
		Thread t0 = new Demo("啊斌");
		Thread t1 = new Demo("雨烟");
		
		//开启线程
		t0.start();
		t1.start();
		
		//main线程
		for (int i = 0; i < 5; i++) { //获得当前线程对象，并获取线程名
			System.out.println(Thread.currentThread().getName());
		}

	}

}

Thread.currentThread()：获得当前线程对象。

输出：（每次运行的结果都会不一样）

main
Thread-0 ————> 啊斌
Thread-1 ————> 雨烟
Thread-0 ————> 啊斌
main
main
main
main
Thread-0 ————> 啊斌
Thread-0 ————> 啊斌
Thread-0 ————> 啊斌
Thread-1 ————> 雨烟
Thread-1 ————> 雨烟
Thread-1 ————> 雨烟
Thread-1 ————> 雨烟

创建线程时的默认命名，以数字递增。实现方式是Thread类内部维护了一个 private static int XXX; 私有静态的int，每构造一个Thread对象后递增。

2. 实现Runnable接口创建线程

实现Runnable接口，重写run()方法，创建Runnable对象，构造Thread( Runnable对象 )对象，调用start()开启线程。

package com.bin.demo;

class Demo implements Runnable {
	
	private String name;
	
	Demo(String name) {
		this.name = name;
	}
	
	@Override
	public void run() {
		for (int i = 0; i < 5; i++) { //获得当前线程对象，并获取线程名
			System.out.println(Thread.currentThread().getName() + " ————> " + name);
		}
	}
}

public class Main {

	public static void main(String[] args) throws InterruptedException {
		
		//创建Runnable对象
		Runnable run0 = new Demo("啊斌");
		Runnable run1 = new Demo("雨烟");

		//创建线程对象
		Thread t0 = new Thread(run0);
		Thread t1 = new Thread(run1);
		
		//开启线程
		t0.start();
		t1.start();
		
		//main线程
		for (int i = 0; i < 5; i++) { //获得当前线程对象，并获取线程名
			System.out.println(Thread.currentThread().getName());
		}

	}

}

输出：

main
Thread-0 ————> 啊斌
Thread-0 ————> 啊斌
Thread-0 ————> 啊斌
Thread-1 ————> 雨烟
Thread-1 ————> 雨烟
main
main
main
main
Thread-0 ————> 啊斌
Thread-0 ————> 啊斌
Thread-1 ————> 雨烟
Thread-1 ————> 雨烟
Thread-1 ————> 雨烟

3. 实现Runnable接口的好处

  1. 避免了继承Thread单继承的局限性（这样就能继承其它类）。
  2. Runnable接口的出现更符合面向对象，将线程任务进行单独的封装。
  3. 降低了Thread线程对象和Runnable线程任务的耦合性。

调用start()和run()的区别

  • 为什么不直接调用Thread的run()方法，而是调用start()方法呢？
  • start()方法是调用底层函数，此函数会请求设备创建一条新线程，并加载run()方法进入新线程的栈内存。
  • 如果直接调用run()方法，不会请求设备创建一条新线程，只会被当前线程（调用者）加载进当前线程的栈内存。而run()方法仅仅是提供给程序员重写的方法。

多线程内存图（简）

为什么多线程的方法能一同执行？这不就违背了Java栈先进后出的规则了吗？接下来用一张图来解析：

看图可见，在创建新线程时，JVM的栈内存中分配了对应线程的栈内存。这就能说明多线程中的方法执行顺序是互不干扰的。

多线程的运行状态

了解多线程的状态，掌握线程的生命周期。

所有线程都结束时，进程才结束。

在JDK1.5后，Java线程状态单独用一个类进行了描述：

多线程同步

多线程同步产生的问题：

  1. 多线程任务处理到共享的数据。
  2. 多线程任务中有多条代码对共享数据的操作。

一个线程在操作共享数据的过程中，其它线程参与了运算，造成了数据的错误。

解决思想：

        只要保证操作共享数据的多条代码在一个时间段，被一条线程所执行，执行期间不允许其它线程参与操作。

1. 多线程卖票产生的问题

package com.bin.demo;

class Ticket implements Runnable {
	
	private int data = 20; //多线程操作任务的共享数据
	
	@Override
	public void run() {
		
		while (data > 0) {
			System.out.println(Thread.currentThread().getName() + " ————> " + data--); //卖出一张票，并递减
		}
		
	}
}

public class Main {

	public static void main(String[] args) throws InterruptedException {
		
		//创建Runnable对象
		Runnable run = new Ticket();

		//创建线程对象
		Thread t0 = new Thread(run);
		Thread t1 = new Thread(run);
		Thread t2 = new Thread(run);
		
		//开启线程
		t0.start();
		t1.start();
		t2.start();
		
	}

}

输出：

Thread-1 ————> 20
Thread-0 ————> 20
Thread-2 ————> 19
Thread-0 ————> 17
Thread-0 ————> 15
Thread-0 ————> 14
Thread-0 ————> 13
Thread-0 ————> 12
Thread-0 ————> 11
Thread-0 ————> 10
Thread-0 ————> 9
Thread-0 ————> 8
Thread-0 ————> 7
Thread-0 ————> 6
Thread-0 ————> 5
Thread-1 ————> 18
Thread-1 ————> 3
Thread-1 ————> 2
Thread-1 ————> 1
Thread-0 ————> 4
Thread-2 ————> 16

图解分析问题：

2. 同步代码块

解决卖票问题：把需要同步的多条代码使用synchronized同步关键字进行同步。

2.1 synchronized ( Lock ) { code... }

  • 同步的前提：Lock参数，可以是任意类型的对象，每条线程必须使用同一个锁对象。
	@Override
	public void run() {
		
		while (data > 0) {
			
			synchronized (this) { //this：调用者对象Ticket
				System.out.println(Thread.currentThread().getName() + " ————> " + data--); //卖出一张票，并递减
			}
			
		}
		
	}

输出：

Thread-0 ————> 20
Thread-1 ————> 19
Thread-1 ————> 18
Thread-1 ————> 17
Thread-1 ————> 16
Thread-1 ————> 15
Thread-1 ————> 14
Thread-0 ————> 13
Thread-0 ————> 12
Thread-0 ————> 11
Thread-0 ————> 10
Thread-0 ————> 9
Thread-0 ————> 8
Thread-0 ————> 7
Thread-0 ————> 6
Thread-0 ————> 5
Thread-0 ————> 4
Thread-0 ————> 3
Thread-0 ————> 2
Thread-0 ————> 1
Thread-2 ————> 0
Thread-1 ————> -1

新问题图解：

2.2 双重判断-解决

观察代码，只要线程得到锁进同步代码块内，再次判断data数据是否大于0。

	@Override
	public void run() {
		
		while (data > 0) {
			synchronized (this) { //this：调用者对象Ticket
				if (data > 0) { //解决
					System.out.println(Thread.currentThread().getName() + " ————> " + data--); //卖出一张票，并递减
				}
			}
		}
		
	}

输出：

Thread-0 ————> 20
Thread-0 ————> 19
Thread-0 ————> 18
Thread-0 ————> 17
Thread-0 ————> 16
Thread-0 ————> 15
Thread-0 ————> 14
Thread-0 ————> 13
Thread-0 ————> 12
Thread-0 ————> 11
Thread-0 ————> 10
Thread-1 ————> 9
Thread-2 ————> 8
Thread-2 ————> 7
Thread-2 ————> 6
Thread-2 ————> 5
Thread-2 ————> 4
Thread-2 ————> 3
Thread-2 ————> 2
Thread-2 ————> 1

3. 同步函数

  • synchronized关键字修饰函数，就是同步函数。
  • 不需要程序员传锁。
  • 非静态同步函数使用this锁，静态同步函数使用 （字节码对象）类.class锁，类型为Class。（重点注意）
class Ticket implements Runnable {
	
	private int data = 20; //多线程操作任务的共享数据
	
	@Override
	public void run() {
		while (data > 0) {
			ticket();
		}
	}
	
	private synchronized void ticket() { //同步函数
		if (data > 0) { //再次判断，防止数据出错
			System.out.println(Thread.currentThread().getName() + " ————> " + data--); //卖出一张票，并递减
		}
	}
	
}

输出：

Thread-1 ————> 20
Thread-1 ————> 19
Thread-1 ————> 18
Thread-1 ————> 17
Thread-1 ————> 16
Thread-1 ————> 15
Thread-1 ————> 14
Thread-1 ————> 13
Thread-1 ————> 12
Thread-1 ————> 11
Thread-1 ————> 10
Thread-1 ————> 9
Thread-1 ————> 8
Thread-2 ————> 7
Thread-2 ————> 6
Thread-2 ————> 5
Thread-2 ————> 4
Thread-2 ————> 3
Thread-2 ————> 2
Thread-2 ————> 1

3.1 锁的作用域

线程在拿到一个锁后，在此同步关键字的作用域下都能拿到此锁。

3.2 验证非静态同步函数使用 this 锁

package com.bin.demo;

class Task implements Runnable {
	
	@Override
	public void run() {
		test();
	}
	
	private synchronized void test() {
		synchronized (this) {
			System.out.println("我是非静态同步函数");
		}
	}
	
}

public class Main {

	public static void main(String[] args) throws InterruptedException {
		
		new Thread(new Task()).start();
		
	}

}

输出：

我是非静态同步函数

3.3 验证静态同步函数使用 类.class 锁

package com.bin.demo;

class Task implements Runnable {
	
	@Override
	public void run() {
		test();
	}
	
	private static synchronized void test() {
		synchronized (Task.class) {
			System.out.println("我是静态同步函数");
		}
	}
	
}

public class Main {

	public static void main(String[] args) throws InterruptedException {
		
		new Thread(new Task()).start();
		
	}

}

输出：

我是静态同步函数

4. 同步代码块与同步函数的区别

同步代码块较为优势，能自定义锁，能锁住需要同步的代码片段，而不是全部代码。

	@Override
	public void run() {
		
        code...

	        synchronized (lock) {
	            code...
	        }

        code...

	}

同步函数写法简单，不能自定义锁，直接锁主一个方法，较为局限。而且在某些情况下还会降低同步性能。

5. 同步好处与弊端

好处：解决多线程操作共性数据的安全问题。

弊端：消耗CPU资源（锁的判断：在某一条线程拿到锁后，其它线程是拿不到锁的（这里就是一系列的锁判断），直到持有锁的线程释放锁后，其它线程才有机会拿到锁。），效率降低。（用性能换取安全性是可接受的）

图解弊端：

6. 练习：单列模式并发访问（性能对比）

针对懒汉式单列模式

饿汉式在没有执行静态方法时，类加载就创建对象了，饿汉式是线程安全的

package com.bin.demo;

class SingleA { //同步函数
	
	private static SingleA instance;
	
	private SingleA() {
		super();
	}
	
	/*
	 * 每条线程执行时都要判断锁才能进入方法
	 * 如果第一条线程拿到锁进入并已创建对象，但锁未释放，切换到其它线程时都不能进入方法内，
	 * 只有等到再次切换回持有锁的线程释放锁后，其它线程才有机会拿到锁。
	 * 也就是每一条线程要进入同步方法都必须判断锁。
	 */
	public static synchronized SingleA getInstance() {
		if (null == instance) {
			instance = new SingleA();
		}
		return instance;
	}
	
}

class SingleB { //同步代码块
	
	private static SingleB instance;
	
	private SingleB() {
		super();
	}
	
	/*
	 * 每条线程直接进方法内
	 * 如果第一条线程进入方法拿到锁并创建对象，但锁未释放，切换到其它线程进入方法就直接返回对象了。
	 * 此后后面每一条线程不用判断锁直接返回对象。
	 */
	public static SingleB getInstance() {
		if (null == instance) { //双重判断
			synchronized (SingleB.class) {
				if (null == instance) { //双重判断
					instance = new SingleB(); //需要同步的代码
				}
			}
		}
		return instance;
	}
	
}

class Run implements Runnable {
	
	private boolean isFun;
	
	Run (boolean isFun) {
		this.isFun = isFun;
	}
	
	@Override
	public void run() {
		long time = System.currentTimeMillis(); //获得开始执行时间
		int runCount = 10000000; //每条线程执行次数
		
		if (isFun) {
			for (int i = 0; i < runCount; i++) {
				SingleA.getInstance(); //同步函数
			}
		} else {
			for (int i = 0; i < runCount; i++) {
				SingleB.getInstance(); //同步代码块
			}
		}
		
		long endTime = System.currentTimeMillis() - time; //计算出运行结束时间
		String name = isFun ? "函数 ：" : "代码块：";
		System.out.println(name +  Thread.currentThread().getName() + " ————> " + endTime + "ms 执行完毕");
	}
	
}

public class Main {

	public static void main(String[] args) throws InterruptedException {
		
		//创建Runnable对象
		Run runA = new Run(true); //同步函数
		Run runB = new Run(false); //同步代码块

		//创建线程对象
		Thread t0 = new Thread(runA);
		Thread t1 = new Thread(runA);
		Thread t2 = new Thread(runA);
		
		Thread t3 = new Thread(runB);
		Thread t4 = new Thread(runB);
		Thread t5 = new Thread(runB);
		
		//开启线程
		t0.start();
		t1.start();
		t2.start();
		
		t3.start();
		t4.start();
		t5.start();
		
	}

}

输出：

函数 ：Thread-2 ————> 442ms 执行完毕
函数 ：Thread-1 ————> 632ms 执行完毕
函数 ：Thread-0 ————> 638ms 执行完毕

代码块：Thread-3 ————> 41ms 执行完毕
代码块：Thread-4 ————> 58ms 执行完毕
代码块：Thread-5 ————> 59ms 执行完毕

可见同步代码块的速度，因为同步代码块用了双重判断。

死锁

概念：所有的线程都处于冻结状态——>假死状态。（程序员无法得知问题出现，也不会发生程序的异常）

场景一：同步嵌套。

场景二：手动暂停挂起线程。

场景一：同步嵌套

package com.bin.demo;

class MyLock { //定义两个锁
	public static final Object LOCK_A = new Object();
	public static final Object LOCK_B = new Object();
}

class Task implements Runnable {
	
	private boolean flag;
	
	Task(boolean flag) {
		this.flag = flag;
	}

	@Override
	public void run() {
		if (flag) {
			while (true) {
				synchronized (MyLock.LOCK_A) {
					System.out.println(Thread.currentThread().getName() + "_if ————> LockA");
					synchronized (MyLock.LOCK_B) {
						System.out.println(Thread.currentThread().getName() + "_if ————> LockB");
					}
					
				}
			}
		} else {
			while (true) {
				synchronized (MyLock.LOCK_B) {
					System.out.println(Thread.currentThread().getName() + "_else ————> LockB");
					synchronized (MyLock.LOCK_A) {
						System.out.println(Thread.currentThread().getName() + "_else ————> LockA");
					}
					
				}
			}
		}
	}
	
}

public class Main {

	public static void main(String[] args) throws InterruptedException {
		
		//创建Runnable对象
		Task runA = new Task(true);
		Task runB = new Task(false);

		//创建线程对象
		Thread t0 = new Thread(runA);
		Thread t1 = new Thread(runB);
		
		//开启线程
		t0.start();
		t1.start();
		
	}

}

输出：

Thread-0_if ————> LockA
Thread-1_else ————> LockB

这里直接加无限循环。可见输出只有两行。

死锁过程：

  1. 假如Thread-0得到CPU资源拿到锁A，这时候CPU马上切换到了Thread-1。
  2. Thread-1得到CPU资源拿到锁B，继续向下执行判断同步锁A已被Thread-0拿走，则在此等待。
  3. CPU切回Thread-0向下执行代码，判断同步锁B已被Thread-1拿走，则在此等待。
  4. 这时候Thread-0和Thread-1都已经处于挂起状态，谁都拿着对方需要的锁不放，导致线程无法继续向下运行。

当然也有和谐的情况，一条线程执行代码直接拿走两个锁后就退出了，所以加无限循环直接看效果。

多线程间的通信

此章节内容较多，主要是代码较多，主要是个人练习，看不过去的可以直接看到Lock接口

首先得了解需要讲解的方法：

1. 线程等待唤醒机制

在使用同步语句synchronized时，锁是任意的，任意对象都有的方法【Object】，与线程相关的方法：

Object

  • wait()：冻结此监视器（锁）上的线程。该方法可以让线程冻结，并将线程存储到线程池中。
  • notify()：唤醒此监视器（锁）任意一条线程。取出并唤醒指定线程池中任意一条线程。
  • notifyAll()：唤醒此监视器（锁）上全部线程。取出并唤醒指定线程池中所有的线程。

非常注意：

  1. 这些方法必须在同步上使用，因为它们用来操作同步锁上线程的状态。
  2. 使用这些方法时，必须明确所属的锁，标示方式：锁对象.wait()、锁对象.notify()、锁对象.notifyAll()。
  3. wait()方法，会让当前监视器（锁）下的线程仅冻结于当前行。
  4. notify()和notifyAll()方法允许null唤醒，也就是线程池无线程时什么都不做。

线程池

2. 多生产多消费例子

package com.bin.demo;

class Res { //资源
	
	private String name; //商品名
	private String[] ress; //存储商品容器
	private int count; //商品数量
	private int code; //商品编号
	private static final int MAX_COUNT = 20; //可存储的最大容量
	
	Res(String name) {
		ress = new String[MAX_COUNT]; //资源最大存储容量
		this.name = name;
	}
	
	public synchronized void put() {
		while (!(count < MAX_COUNT)) { //检查商品未满
			try {
				System.out.println("生产线程：" + Thread.currentThread().getName() + "......已暂停");
				this.wait(); //商品满了就暂停生产
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
		ress[count++] = name + " [" + ++code + "]"; //添加商品，count++更新商品数量，++code对商品进行顺序编号
		System.out.println(Thread.currentThread().getName() + " 生产 ++++>" + ress[count - 1]);
		this.notifyAll(); //唤醒全部线程
	}
	
	public synchronized void get() {
		while (!(count > 0)) { //检查是否有商品
			try {
				System.out.println("消费线程：" + Thread.currentThread().getName() + "......已暂停");
				this.wait(); //没有商品则在这里等待
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
		--count;
		String obj = ress[count];
		ress[count] = null;
		System.out.println(Thread.currentThread().getName() + " 消费 ------->" + obj);
		this.notifyAll(); //唤醒全部线程
	}
	
}

class Producer implements Runnable {
	
	private Res r;
	
	Producer(Res r) {
		this.r = r;
	}

	@Override
	public void run() {
		for (int i = 0; i < 30; i++) {
			r.put();
		}
	}
	
}

class Consumer implements Runnable {
	
	private Res r;
	
	Consumer(Res r) {
		this.r = r;
	}

	@Override
	public void run() {
		for (int i = 0; i < 30; i++) {
			r.get();
		}
	}
	
}

public class Main {

	public static void main(String[] args) throws InterruptedException {
		
		long time = System.currentTimeMillis();
		
		//创建资源
		Res r = new Res("雷姆");
		
		//创建任务
		Producer pro = new Producer(r);
		Consumer con = new Consumer(r);
		
		//创建线程
		Thread t0 = new Thread(pro);
		Thread t1 = new Thread(pro);
		Thread t2 = new Thread(pro);
		Thread t3 = new Thread(con);
		Thread t4 = new Thread(con);
		Thread t5 = new Thread(con);
		
		t0.start();
		t1.start();
		t2.start();
		t3.start();
		t4.start();
		t5.start();
		
		//main线程等待子线程结束
		t0.join();
		t1.join();
		t2.join();
		t3.join();
		t4.join();
		t5.join();
		
		System.out.println("用时 = " + (System.currentTimeMillis() - time) + "ms");
	}

}

输出：

Thread-0 生产 ++++>雷姆 [1]
Thread-0 生产 ++++>雷姆 [2]
Thread-0 生产 ++++>雷姆 [3]
Thread-0 生产 ++++>雷姆 [4]
Thread-0 生产 ++++>雷姆 [5]
Thread-0 生产 ++++>雷姆 [6]
Thread-0 生产 ++++>雷姆 [7]
Thread-0 生产 ++++>雷姆 [8]
Thread-0 生产 ++++>雷姆 [9]
Thread-0 生产 ++++>雷姆 [10]
Thread-0 生产 ++++>雷姆 [11]
Thread-0 生产 ++++>雷姆 [12]
Thread-5 消费 ------->雷姆 [12]
Thread-5 消费 ------->雷姆 [11]
Thread-5 消费 ------->雷姆 [10]
Thread-5 消费 ------->雷姆 [9]
Thread-5 消费 ------->雷姆 [8]
Thread-5 消费 ------->雷姆 [7]
Thread-5 消费 ------->雷姆 [6]
Thread-3 消费 ------->雷姆 [5]
Thread-3 消费 ------->雷姆 [4]
Thread-3 消费 ------->雷姆 [3]
Thread-3 消费 ------->雷姆 [2]
Thread-3 消费 ------->雷姆 [1]
消费线程：Thread-3......已暂停
消费线程：Thread-4......已暂停
Thread-1 生产 ++++>雷姆 [13]
Thread-1 生产 ++++>雷姆 [14]
Thread-1 生产 ++++>雷姆 [15]
Thread-1 生产 ++++>雷姆 [16]
Thread-1 生产 ++++>雷姆 [17]
Thread-1 生产 ++++>雷姆 [18]
Thread-1 生产 ++++>雷姆 [19]
Thread-1 生产 ++++>雷姆 [20]
Thread-1 生产 ++++>雷姆 [21]
Thread-1 生产 ++++>雷姆 [22]
Thread-1 生产 ++++>雷姆 [23]
Thread-1 生产 ++++>雷姆 [24]
Thread-1 生产 ++++>雷姆 [25]
Thread-1 生产 ++++>雷姆 [26]
Thread-1 生产 ++++>雷姆 [27]
Thread-1 生产 ++++>雷姆 [28]
Thread-1 生产 ++++>雷姆 [29]
Thread-1 生产 ++++>雷姆 [30]
Thread-1 生产 ++++>雷姆 [31]
Thread-1 生产 ++++>雷姆 [32]
生产线程：Thread-1......已暂停
生产线程：Thread-2......已暂停
Thread-4 消费 ------->雷姆 [32]
Thread-4 消费 ------->雷姆 [31]
Thread-4 消费 ------->雷姆 [30]
Thread-4 消费 ------->雷姆 [29]
Thread-4 消费 ------->雷姆 [28]
Thread-4 消费 ------->雷姆 [27]
Thread-4 消费 ------->雷姆 [26]
Thread-4 消费 ------->雷姆 [25]
Thread-4 消费 ------->雷姆 [24]
Thread-4 消费 ------->雷姆 [23]
Thread-4 消费 ------->雷姆 [22]
Thread-4 消费 ------->雷姆 [21]
Thread-4 消费 ------->雷姆 [20]
Thread-4 消费 ------->雷姆 [19]
Thread-4 消费 ------->雷姆 [18]
Thread-4 消费 ------->雷姆 [17]
Thread-4 消费 ------->雷姆 [16]
Thread-4 消费 ------->雷姆 [15]
Thread-4 消费 ------->雷姆 [14]
Thread-4 消费 ------->雷姆 [13]
消费线程：Thread-4......已暂停
消费线程：Thread-3......已暂停
消费线程：Thread-5......已暂停
Thread-0 生产 ++++>雷姆 [33]
Thread-0 生产 ++++>雷姆 [34]
Thread-0 生产 ++++>雷姆 [35]
Thread-0 生产 ++++>雷姆 [36]
Thread-0 生产 ++++>雷姆 [37]
Thread-0 生产 ++++>雷姆 [38]
Thread-0 生产 ++++>雷姆 [39]
Thread-0 生产 ++++>雷姆 [40]
Thread-0 生产 ++++>雷姆 [41]
Thread-0 生产 ++++>雷姆 [42]
Thread-0 生产 ++++>雷姆 [43]
Thread-0 生产 ++++>雷姆 [44]
Thread-0 生产 ++++>雷姆 [45]
Thread-0 生产 ++++>雷姆 [46]
Thread-0 生产 ++++>雷姆 [47]
Thread-0 生产 ++++>雷姆 [48]
Thread-0 生产 ++++>雷姆 [49]
Thread-0 生产 ++++>雷姆 [50]
Thread-5 消费 ------->雷姆 [50]
Thread-5 消费 ------->雷姆 [49]
Thread-5 消费 ------->雷姆 [48]
Thread-5 消费 ------->雷姆 [47]
Thread-5 消费 ------->雷姆 [46]
Thread-3 消费 ------->雷姆 [45]
Thread-3 消费 ------->雷姆 [44]
Thread-3 消费 ------->雷姆 [43]
Thread-3 消费 ------->雷姆 [42]
Thread-3 消费 ------->雷姆 [41]
Thread-3 消费 ------->雷姆 [40]
Thread-3 消费 ------->雷姆 [39]
Thread-3 消费 ------->雷姆 [38]
Thread-3 消费 ------->雷姆 [37]
Thread-3 消费 ------->雷姆 [36]
Thread-3 消费 ------->雷姆 [35]
Thread-3 消费 ------->雷姆 [34]
Thread-3 消费 ------->雷姆 [33]
消费线程：Thread-3......已暂停
消费线程：Thread-4......已暂停
Thread-2 生产 ++++>雷姆 [51]
Thread-2 生产 ++++>雷姆 [52]
Thread-2 生产 ++++>雷姆 [53]
Thread-2 生产 ++++>雷姆 [54]
Thread-2 生产 ++++>雷姆 [55]
Thread-2 生产 ++++>雷姆 [56]
Thread-2 生产 ++++>雷姆 [57]
Thread-2 生产 ++++>雷姆 [58]
Thread-2 生产 ++++>雷姆 [59]
Thread-2 生产 ++++>雷姆 [60]
Thread-2 生产 ++++>雷姆 [61]
Thread-2 生产 ++++>雷姆 [62]
Thread-2 生产 ++++>雷姆 [63]
Thread-2 生产 ++++>雷姆 [64]
Thread-2 生产 ++++>雷姆 [65]
Thread-2 生产 ++++>雷姆 [66]
Thread-2 生产 ++++>雷姆 [67]
Thread-2 生产 ++++>雷姆 [68]
Thread-2 生产 ++++>雷姆 [69]
Thread-1 生产 ++++>雷姆 [70]
生产线程：Thread-1......已暂停
生产线程：Thread-2......已暂停
Thread-4 消费 ------->雷姆 [70]
Thread-4 消费 ------->雷姆 [69]
Thread-4 消费 ------->雷姆 [68]
Thread-4 消费 ------->雷姆 [67]
Thread-4 消费 ------->雷姆 [66]
Thread-4 消费 ------->雷姆 [65]
Thread-4 消费 ------->雷姆 [64]
Thread-4 消费 ------->雷姆 [63]
Thread-4 消费 ------->雷姆 [62]
Thread-4 消费 ------->雷姆 [61]
Thread-3 消费 ------->雷姆 [60]
Thread-3 消费 ------->雷姆 [59]
Thread-3 消费 ------->雷姆 [58]
Thread-3 消费 ------->雷姆 [57]
Thread-3 消费 ------->雷姆 [56]
Thread-3 消费 ------->雷姆 [55]
Thread-3 消费 ------->雷姆 [54]
Thread-3 消费 ------->雷姆 [53]
Thread-3 消费 ------->雷姆 [52]
Thread-3 消费 ------->雷姆 [51]
消费线程：Thread-3......已暂停
消费线程：Thread-5......已暂停
Thread-2 生产 ++++>雷姆 [71]
Thread-2 生产 ++++>雷姆 [72]
Thread-2 生产 ++++>雷姆 [73]
Thread-2 生产 ++++>雷姆 [74]
Thread-2 生产 ++++>雷姆 [75]
Thread-2 生产 ++++>雷姆 [76]
Thread-2 生产 ++++>雷姆 [77]
Thread-2 生产 ++++>雷姆 [78]
Thread-2 生产 ++++>雷姆 [79]
Thread-2 生产 ++++>雷姆 [80]
Thread-2 生产 ++++>雷姆 [81]
Thread-1 生产 ++++>雷姆 [82]
Thread-1 生产 ++++>雷姆 [83]
Thread-1 生产 ++++>雷姆 [84]
Thread-1 生产 ++++>雷姆 [85]
Thread-1 生产 ++++>雷姆 [86]
Thread-1 生产 ++++>雷姆 [87]
Thread-1 生产 ++++>雷姆 [88]
Thread-1 生产 ++++>雷姆 [89]
Thread-1 生产 ++++>雷姆 [90]
Thread-5 消费 ------->雷姆 [90]
Thread-5 消费 ------->雷姆 [89]
Thread-5 消费 ------->雷姆 [88]
Thread-3 消费 ------->雷姆 [87]
Thread-3 消费 ------->雷姆 [86]
Thread-5 消费 ------->雷姆 [85]
Thread-5 消费 ------->雷姆 [84]
Thread-5 消费 ------->雷姆 [83]
Thread-5 消费 ------->雷姆 [82]
Thread-5 消费 ------->雷姆 [81]
Thread-5 消费 ------->雷姆 [80]
Thread-5 消费 ------->雷姆 [79]
Thread-5 消费 ------->雷姆 [78]
Thread-5 消费 ------->雷姆 [77]
Thread-5 消费 ------->雷姆 [76]
Thread-5 消费 ------->雷姆 [75]
Thread-5 消费 ------->雷姆 [74]
Thread-5 消费 ------->雷姆 [73]
Thread-5 消费 ------->雷姆 [72]
Thread-5 消费 ------->雷姆 [71]
用时 = 27ms

JDK1.4版本前多生产与消费唤醒机制效率问题

每次唤醒都要唤醒全部生产线程与消费线程，也就是在生产唤醒消费线程的同时唤醒了本方生产线程，生产线程也一样。

这是不必要的性能损耗，所以从JDK1.5后出现了新的方案。

3. JDK1.5版本Lock接口

 常用方法：

  • lock()：获取锁。

  • unlock()：释放锁。

  • newCondition()：每次调用都会创建新的Condition实例，此对象封装了绑定Lock的监视器（锁）方法。如wait()、notify()、notifyAll()方法。每一个Condition实例都对应着不同的线程池。

Lock接口对象替代了synchronized语句，但是失去了隐式的自动获取锁与自动释放锁的机制，所以要显示获取与释放锁，

Lock使用：

l.lock();
try {
// code...
} finally {
    l.unlock();
}

3.1 JDK1.5版本Condition接口

Condition接口替代了Object的监视器方法。并起了新名字：

  • await()：同wait()。
  • signal()：同notify()。
  • signalAll()：同natifyAll()。

Condition的使用：

	final Lock lock = new ReentrantLock(); //创建Lock接口实现类
	final Condition con_A  = lock.newCondition(); //获得与lock绑定的监视器对象
	final Condition con_B = lock.newCondition(); //获得与lock绑定的监视器对象

	public void add() {
		lock.lock();
		try {
			con_A.await(); //存入con_A线程池
			
			//code...
			//code...
			//code...
			
			con_B.signalAll(); //通知con_B线程池
		} catch (InterruptedException e) {
			e.printStackTrace();
		} finally {
			lock.unlock();
		}
	}

	public void remove() {
		lock.lock();
		try {
			con_B.await(); //存入con_B线程池
			
			//code...
			//code...
			//code...
			
			con_A.signalAll(); //通知con_A线程池
		} catch (InterruptedException e) {
			e.printStackTrace();
		} finally {
			lock.unlock();
		}
	}

3.2 使用Lock接口的好处

  • 用一个lock锁同步需要的代码（废话）
  • 利用绑定此lock锁的Condition接口监视器，存入指定线程池或唤醒指定线程池中的线程。
  • 解决1.4版本前同步锁不必要的唤醒开销。

对比1.4前同步锁，与1.5同步锁：

4. 多生产多消费效率解决

在了解Lock接口的锁后，我们就可以解决多生产、消费问题。就能指定存入与唤醒线程池中的线程。解决不必要的性能开销。

更改Res类

class Res { //资源
	
	private String name; //商品名
	private String[] ress; //存储商品容器
	private int count; //商品数量
	private int code; //商品编号
	private static final int MAX_COUNT = 20; //可存储的最大容量
	
	//JDK1.5新唤醒机制
	final Lock lock = new ReentrantLock();
	final Condition producer_con  = lock.newCondition();
	final Condition consumer_con = lock.newCondition();
	
	Res(String name) {
		ress = new String[MAX_COUNT]; //资源最大存储容量
		this.name = name;
	}
	
	public void put() {
		lock.lock();
		try {
			while (!(count < MAX_COUNT)) { //检查商品未满
				System.out.println("生产线程：" + Thread.currentThread().getName() + "......已暂停");
				producer_con.await(); //商品满了就暂停生产
			}
			ress[count++] = name + " [" + ++code + "]"; //添加商品，count++更新商品数量，++code对商品进行顺序编号
			System.out.println(Thread.currentThread().getName() + " 生产 ++++>" + ress[count - 1]);
			consumer_con.signalAll(); //唤醒消费者
		} catch (InterruptedException e) {
			e.printStackTrace();
		} finally {
			lock.unlock();
		}
	}
	
	public void get() {
		lock.lock();
		try {
			while (!(count > 0)) { //检查是否有商品
				System.out.println("消费线程：" + Thread.currentThread().getName() + "......已暂停");
				consumer_con.await(); //没有商品则在这里等待
			}
			--count;
			String obj = ress[count];
			ress[count] = null;
			System.out.println(Thread.currentThread().getName() + " 消费 ------->" + obj);
			producer_con.signalAll(); //唤醒生产者
		} catch (InterruptedException e) {
			e.printStackTrace();
		} finally {
			lock.unlock();
		}
	}
	
}

输出：

Thread-1 生产 ++++>雷姆 [1]
Thread-3 消费 ------->雷姆 [1]
消费线程：Thread-3......已暂停
Thread-0 生产 ++++>雷姆 [2]
Thread-0 生产 ++++>雷姆 [3]
Thread-0 生产 ++++>雷姆 [4]
Thread-0 生产 ++++>雷姆 [5]
Thread-0 生产 ++++>雷姆 [6]
Thread-0 生产 ++++>雷姆 [7]
Thread-0 生产 ++++>雷姆 [8]
Thread-0 生产 ++++>雷姆 [9]
Thread-0 生产 ++++>雷姆 [10]
Thread-0 生产 ++++>雷姆 [11]
Thread-0 生产 ++++>雷姆 [12]
Thread-0 生产 ++++>雷姆 [13]
Thread-0 生产 ++++>雷姆 [14]
Thread-0 生产 ++++>雷姆 [15]
Thread-0 生产 ++++>雷姆 [16]
Thread-0 生产 ++++>雷姆 [17]
Thread-0 生产 ++++>雷姆 [18]
Thread-0 生产 ++++>雷姆 [19]
Thread-0 生产 ++++>雷姆 [20]
Thread-0 生产 ++++>雷姆 [21]
生产线程：Thread-0......已暂停
生产线程：Thread-2......已暂停
生产线程：Thread-1......已暂停
Thread-4 消费 ------->雷姆 [21]
Thread-4 消费 ------->雷姆 [20]
Thread-4 消费 ------->雷姆 [19]
Thread-4 消费 ------->雷姆 [18]
Thread-4 消费 ------->雷姆 [17]
Thread-4 消费 ------->雷姆 [16]
Thread-4 消费 ------->雷姆 [15]
Thread-4 消费 ------->雷姆 [14]
Thread-4 消费 ------->雷姆 [13]
Thread-4 消费 ------->雷姆 [12]
Thread-4 消费 ------->雷姆 [11]
Thread-4 消费 ------->雷姆 [10]
Thread-4 消费 ------->雷姆 [9]
Thread-4 消费 ------->雷姆 [8]
Thread-4 消费 ------->雷姆 [7]
Thread-4 消费 ------->雷姆 [6]
Thread-4 消费 ------->雷姆 [5]
Thread-4 消费 ------->雷姆 [4]
Thread-4 消费 ------->雷姆 [3]
Thread-4 消费 ------->雷姆 [2]
消费线程：Thread-4......已暂停
消费线程：Thread-5......已暂停
消费线程：Thread-3......已暂停
Thread-0 生产 ++++>雷姆 [22]
Thread-0 生产 ++++>雷姆 [23]
Thread-0 生产 ++++>雷姆 [24]
Thread-0 生产 ++++>雷姆 [25]
Thread-0 生产 ++++>雷姆 [26]
Thread-0 生产 ++++>雷姆 [27]
Thread-0 生产 ++++>雷姆 [28]
Thread-0 生产 ++++>雷姆 [29]
Thread-0 生产 ++++>雷姆 [30]
Thread-0 生产 ++++>雷姆 [31]
Thread-2 生产 ++++>雷姆 [32]
Thread-2 生产 ++++>雷姆 [33]
Thread-2 生产 ++++>雷姆 [34]
Thread-2 生产 ++++>雷姆 [35]
Thread-2 生产 ++++>雷姆 [36]
Thread-2 生产 ++++>雷姆 [37]
Thread-2 生产 ++++>雷姆 [38]
Thread-2 生产 ++++>雷姆 [39]
Thread-2 生产 ++++>雷姆 [40]
Thread-2 生产 ++++>雷姆 [41]
生产线程：Thread-2......已暂停
生产线程：Thread-1......已暂停
Thread-4 消费 ------->雷姆 [41]
Thread-4 消费 ------->雷姆 [40]
Thread-4 消费 ------->雷姆 [39]
Thread-4 消费 ------->雷姆 [38]
Thread-4 消费 ------->雷姆 [37]
Thread-4 消费 ------->雷姆 [36]
Thread-4 消费 ------->雷姆 [35]
Thread-4 消费 ------->雷姆 [34]
Thread-4 消费 ------->雷姆 [33]
Thread-4 消费 ------->雷姆 [32]
Thread-5 消费 ------->雷姆 [31]
Thread-5 消费 ------->雷姆 [30]
Thread-5 消费 ------->雷姆 [29]
Thread-5 消费 ------->雷姆 [28]
Thread-5 消费 ------->雷姆 [27]
Thread-5 消费 ------->雷姆 [26]
Thread-5 消费 ------->雷姆 [25]
Thread-5 消费 ------->雷姆 [24]
Thread-5 消费 ------->雷姆 [23]
Thread-5 消费 ------->雷姆 [22]
消费线程：Thread-5......已暂停
消费线程：Thread-3......已暂停
Thread-2 生产 ++++>雷姆 [42]
Thread-2 生产 ++++>雷姆 [43]
Thread-2 生产 ++++>雷姆 [44]
Thread-2 生产 ++++>雷姆 [45]
Thread-2 生产 ++++>雷姆 [46]
Thread-2 生产 ++++>雷姆 [47]
Thread-2 生产 ++++>雷姆 [48]
Thread-2 生产 ++++>雷姆 [49]
Thread-2 生产 ++++>雷姆 [50]
Thread-2 生产 ++++>雷姆 [51]
Thread-2 生产 ++++>雷姆 [52]
Thread-2 生产 ++++>雷姆 [53]
Thread-2 生产 ++++>雷姆 [54]
Thread-2 生产 ++++>雷姆 [55]
Thread-2 生产 ++++>雷姆 [56]
Thread-2 生产 ++++>雷姆 [57]
Thread-2 生产 ++++>雷姆 [58]
Thread-2 生产 ++++>雷姆 [59]
Thread-2 生产 ++++>雷姆 [60]
Thread-2 生产 ++++>雷姆 [61]
生产线程：Thread-1......已暂停
Thread-5 消费 ------->雷姆 [61]
Thread-5 消费 ------->雷姆 [60]
Thread-5 消费 ------->雷姆 [59]
Thread-5 消费 ------->雷姆 [58]
Thread-5 消费 ------->雷姆 [57]
Thread-5 消费 ------->雷姆 [56]
Thread-5 消费 ------->雷姆 [55]
Thread-5 消费 ------->雷姆 [54]
Thread-5 消费 ------->雷姆 [53]
Thread-5 消费 ------->雷姆 [52]
Thread-5 消费 ------->雷姆 [51]
Thread-5 消费 ------->雷姆 [50]
Thread-5 消费 ------->雷姆 [49]
Thread-5 消费 ------->雷姆 [48]
Thread-5 消费 ------->雷姆 [47]
Thread-5 消费 ------->雷姆 [46]
Thread-5 消费 ------->雷姆 [45]
Thread-5 消费 ------->雷姆 [44]
Thread-5 消费 ------->雷姆 [43]
Thread-5 消费 ------->雷姆 [42]
消费线程：Thread-3......已暂停
Thread-1 生产 ++++>雷姆 [62]
Thread-1 生产 ++++>雷姆 [63]
Thread-1 生产 ++++>雷姆 [64]
Thread-1 生产 ++++>雷姆 [65]
Thread-1 生产 ++++>雷姆 [66]
Thread-1 生产 ++++>雷姆 [67]
Thread-1 生产 ++++>雷姆 [68]
Thread-1 生产 ++++>雷姆 [69]
Thread-1 生产 ++++>雷姆 [70]
Thread-1 生产 ++++>雷姆 [71]
Thread-1 生产 ++++>雷姆 [72]
Thread-3 消费 ------->雷姆 [72]
Thread-3 消费 ------->雷姆 [71]
Thread-3 消费 ------->雷姆 [70]
Thread-3 消费 ------->雷姆 [69]
Thread-3 消费 ------->雷姆 [68]
Thread-3 消费 ------->雷姆 [67]
Thread-3 消费 ------->雷姆 [66]
Thread-3 消费 ------->雷姆 [65]
Thread-3 消费 ------->雷姆 [64]
Thread-3 消费 ------->雷姆 [63]
Thread-3 消费 ------->雷姆 [62]
消费线程：Thread-3......已暂停
Thread-1 生产 ++++>雷姆 [73]
Thread-1 生产 ++++>雷姆 [74]
Thread-1 生产 ++++>雷姆 [75]
Thread-1 生产 ++++>雷姆 [76]
Thread-1 生产 ++++>雷姆 [77]
Thread-1 生产 ++++>雷姆 [78]
Thread-1 生产 ++++>雷姆 [79]
Thread-1 生产 ++++>雷姆 [80]
Thread-1 生产 ++++>雷姆 [81]
Thread-1 生产 ++++>雷姆 [82]
Thread-1 生产 ++++>雷姆 [83]
Thread-1 生产 ++++>雷姆 [84]
Thread-1 生产 ++++>雷姆 [85]
Thread-1 生产 ++++>雷姆 [86]
Thread-1 生产 ++++>雷姆 [87]
Thread-1 生产 ++++>雷姆 [88]
Thread-1 生产 ++++>雷姆 [89]
Thread-1 生产 ++++>雷姆 [90]
Thread-3 消费 ------->雷姆 [90]
Thread-3 消费 ------->雷姆 [89]
Thread-3 消费 ------->雷姆 [88]
Thread-3 消费 ------->雷姆 [87]
Thread-3 消费 ------->雷姆 [86]
Thread-3 消费 ------->雷姆 [85]
Thread-3 消费 ------->雷姆 [84]
Thread-3 消费 ------->雷姆 [83]
Thread-3 消费 ------->雷姆 [82]
Thread-3 消费 ------->雷姆 [81]
Thread-3 消费 ------->雷姆 [80]
Thread-3 消费 ------->雷姆 [79]
Thread-3 消费 ------->雷姆 [78]
Thread-3 消费 ------->雷姆 [77]
Thread-3 消费 ------->雷姆 [76]
Thread-3 消费 ------->雷姆 [75]
Thread-3 消费 ------->雷姆 [74]
Thread-3 消费 ------->雷姆 [73]
用时 = 22ms

当然这里线程比较少，而且直接同步一个方法，看不出什么性能上的变化。

记住Lock接口的Condition监视器能指定线程存入的线程池和唤醒指定线程池中的线程就OK了。

wait()和sleep()的区别

  1. wait()释放执行权（锁）并释放执行资格，并且wait()方法只能在监视器（锁）上（synchronized）中使用。
  2. sleep()释放执行权，不释放执行资格。
  3. 共同点：wait()和sleep()都能指定传入超时时间。

异常信息在多线程中的阅读

Thread[Thread-0,5,main] //直接输出线程的信息
  • Thread-0：线程名。
  • 5：线程优先级，这个为默认优先级。
  • main：Thread-0所在的线程组，也就是main线程启动的Thread-0线程。
Exception in thread "Thread-0" java.lang.ArithmeticException: / by zero
	at com.bin.demo.Main$1.run(Main.java:11)
  • Exception in thread "Thread-0"：异常在名叫 Thread-0的线程发生。
  • java.lang.ArithmeticException：这个位置是异常所在的包以及类型。
  • : / by zero：这个位置是异常详细信息。
  • at com.bin.demo.Main$1.run(Main.java:11)：异常所在的代码行数，包含了所在包及类，$符号1.run：是因为我这里使用了匿名内部类的方式创建对象，自动取名叫1，然后是1类里的方法名run()，所在位置11行。

线程优先级

Thread中的优先级静态字段：

优先级值范围 1 ~ 10

  • MAX_PRIORITY = 10：最高优先级
  • MIN_PRIORITY = 1：最低优先级
  • NORM_PRIORITY = 5：默认优先级

通过setPriority(int newPriority)方法设置优先级。

小列子理解线程优先级：

package com.bin.demo;

class Task implements Runnable {
	
	private int count = 60;

	@Override
	public void run() {
		sop();
	}
	
	private void sop() {
		for (int i = 0; i < 11; i++) {
			synchronized (this) {
				if (!(count > 0)) {
					return;
				}
				System.out.println(Thread.currentThread() + "————> " + count--);
			}
		}
	}
	
}

public class Main {

	public static void main(String[] args) {
		Runnable task = new Task();
		for (int i = 0; i < 6; i++) {
			if (i < 3) {
				new Thread(task).start();
			} else {
				Thread t = new Thread(task);
				t.setPriority(Thread.MAX_PRIORITY);
				t.start();
			}
		}
	}
}

输出：

Thread[Thread-0,5,main]————> 60
Thread[Thread-0,5,main]————> 59
Thread[Thread-0,5,main]————> 58
Thread[Thread-0,5,main]————> 57
Thread[Thread-0,5,main]————> 56
Thread[Thread-0,5,main]————> 55
Thread[Thread-0,5,main]————> 54
Thread[Thread-0,5,main]————> 53
Thread[Thread-5,10,main]————> 52
Thread[Thread-5,10,main]————> 51
Thread[Thread-5,10,main]————> 50
Thread[Thread-5,10,main]————> 49
Thread[Thread-5,10,main]————> 48
Thread[Thread-5,10,main]————> 47
Thread[Thread-5,10,main]————> 46
Thread[Thread-5,10,main]————> 45
Thread[Thread-5,10,main]————> 44
Thread[Thread-5,10,main]————> 43
Thread[Thread-5,10,main]————> 42
Thread[Thread-1,5,main]————> 41
Thread[Thread-1,5,main]————> 40
Thread[Thread-1,5,main]————> 39
Thread[Thread-1,5,main]————> 38
Thread[Thread-1,5,main]————> 37
Thread[Thread-1,5,main]————> 36
Thread[Thread-1,5,main]————> 35
Thread[Thread-1,5,main]————> 34
Thread[Thread-1,5,main]————> 33
Thread[Thread-1,5,main]————> 32
Thread[Thread-1,5,main]————> 31
Thread[Thread-2,5,main]————> 30
Thread[Thread-2,5,main]————> 29
Thread[Thread-2,5,main]————> 28
Thread[Thread-2,5,main]————> 27
Thread[Thread-2,5,main]————> 26
Thread[Thread-2,5,main]————> 25
Thread[Thread-2,5,main]————> 24
Thread[Thread-2,5,main]————> 23
Thread[Thread-2,5,main]————> 22
Thread[Thread-4,10,main]————> 21
Thread[Thread-4,10,main]————> 20
Thread[Thread-4,10,main]————> 19
Thread[Thread-4,10,main]————> 18
Thread[Thread-4,10,main]————> 17
Thread[Thread-4,10,main]————> 16
Thread[Thread-4,10,main]————> 15
Thread[Thread-4,10,main]————> 14
Thread[Thread-4,10,main]————> 13
Thread[Thread-4,10,main]————> 12
Thread[Thread-4,10,main]————> 11
Thread[Thread-3,10,main]————> 10
Thread[Thread-3,10,main]————> 9
Thread[Thread-3,10,main]————> 8
Thread[Thread-3,10,main]————> 7
Thread[Thread-3,10,main]————> 6
Thread[Thread-3,10,main]————> 5
Thread[Thread-3,10,main]————> 4
Thread[Thread-3,10,main]————> 3
Thread[Thread-3,10,main]————> 2
Thread[Thread-3,10,main]————> 1

设置线程优先级的意义并不是很大，还是取决于CPU的切换算法

join()方法

作用：某一线程A调用了某一线程B对象的join()方法后，线程A将等待线程B执行结束后，线程A才会继续向下执行。

package com.bin.demo;

class Task implements Runnable {
	
	@Override
	public void run() {
		for (int i = 1; i <= 5; i++) {
			System.out.println(Thread.currentThread().getName() + "___" + i);
		}
		System.out.println(Thread.currentThread().getName() + "线程结束");
	}
	
}

public class Main {

	public static void main(String[] args) throws InterruptedException {
		Runnable task = new Task();
		Thread t0 = new Thread(task);
		t0.start();
		t0.join(); //当前线程等待此线程结束再执行（main线程执行了其它线程的join()方法）
		
		System.out.println(Thread.currentThread().getName() + " 线程结束");
	}
}

输出：

Thread-0___1
Thread-0___2
Thread-0___3
Thread-0___4
Thread-0___5
Thread-0线程结束
main 线程结束

注意：join()方法要放到start()方法之后，因为如果线程没启动根本就不用等待。

守护线程

Java中前台线程与后台线程的概念：只要前台线程都结束，不管有多少个后台（守护）线程，这些后台线程都将被强制结束。守护线程即为后台线程。

setDaemon(boolean on) ：使用此方法进行标记线程是否为守护（后台）线程，true守护，默认false前台线程。

package com.bin.demo;

class Task implements Runnable {
	
	@Override
	public void run() {
		boolean flag = true;
		while (flag) { //无限循环
			// not code...
		}
		System.out.println(Thread.currentThread().getName() + "线程结束");
	}
	
}

public class Main {

	public static void main(String[] args) throws InterruptedException {
		Runnable task = new Task();
		
		Thread t0 = new Thread(task);
		t0.setDaemon(true); //标记为守护线程
		t0.start();
		
		Thread t1 = new Thread(task);
		t1.setDaemon(true); //标记为守护线程
		t1.start();
		
		System.out.println(Thread.currentThread().getName() + " 线程结束");
	}
}

输出：

main 线程结束

可见守护线程是无限循环的，main线程结束后，守护线程直接强制结束了。

线程停止

很遗憾的是stop()方法有缺陷已过时不允许使用，已用interrupt()方法替代。

在API文档中的中断一词谁听谁蒙逼。

interrupt()方法：

interrupt()方法的主要功能就是将阻塞状态清除。

下面将用API文档提示的stop()信息描述写一个示列：基于一个变量进行终止运行的代码，如果线程长时间阻塞等待，则使用interrupt()方法中断阻塞等待：

package com.bin.demo;

class Task implements Runnable {
	
	private boolean flag = true;
	
	@Override
	public void run() {
		task();
		System.out.println(Thread.currentThread().getName() + "线程结束");
	}
	
	private synchronized void task() {
		while (flag) { //标记变量
			try {
				this.wait(); //等待
			} catch (InterruptedException e) {
				System.out.println("接收到中断消息 = " + e);
			}
		}
	}
	
	public void setFlag(boolean flag) {
		this.flag = flag;
	}
	
}

public class Main {

	public static void main(String[] args) throws InterruptedException {
		Task task = new Task();
		Thread t0 = new Thread(task);
		t0.start();
		
		long millis = 0L;
		while (true) {
			Thread.sleep(millis += 1000);
			if (millis > 3000) { //3秒后检查
				if (t0.isAlive()) { //检查是否处于活动状态
					task.setFlag(false); //清除标记，退出任务
					t0.interrupt(); //中断等待
					break; //退出while
				}
			}
		}
	}
}

输出：

接收到中断消息 = java.lang.InterruptedException
Thread-0线程结束

调用interrupt()中断线程等待，线程将接收到一个java.lang.InterruptedException异常消息。

虚妄狼
关注
  • 26
    点赞
  • 踩
  • 50
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 6
    评论
专栏目录
Java多线程基础——Lock类
08-31
Lock类是Java类来提供的功能，丰富的api使得Lock类的同步功能比synchronized的同步更强大。本文对此进行详细介绍，下面跟着小编一起来看下吧
Java线程
12-21
目录 理解线程的概念 通过Thread直接创建子线程 实现Runnable接口创建自线程 线程状态（创建、就绪、执行、阻塞、终止） 线程常用方法 inturrupt打断线程 join（）线程并行执行变为串行 理解线程的概念 一个程序至少有一个进程，一个进程至少有一个线程； 线程是进程的一个实体，是CPU调度和分派的基本单位； 一个线程可以创建和撤销另一个线程； 同一个进程中的多个线程之间可以并发执行 在Java中，每次程序运行至少启动2个线程：一个是main线程，一个是垃圾收gc集线程。每当使用java命令执行一个类的时候，实际上都会启动一个JVM，每一个JVM实际上就是在操作系统中启
系统线程（内核线程）和用户线程区别 - 简书.pdf
04-29
系统线程（内核线程）和用户线程区别 - 简书.pdf
import java.io.*; public class FirstPart{ public static void main(String[] args) throws Exception{ System.out.print("The input Fahrenheit is "); BufferedReader br = new BufferedReader(new InputStreamReader(System.in)); int f = Integer.parseInt(br.re
04-11
import java.io.*; public class FirstPart{ public static void main(String[] args) throws Exception{ System.out.print("The input Fahrenheit is "); BufferedReader br = new BufferedReader(new InputStreamReader(System.in)); int f = Integer.parseInt(br.readLine()); double c=5*(f-32); c=c/9; System.out.println("Changing it to Celsius is "+c); } }
C# 跨线程访问UI线程控件
01-20
C# 跨线程访问UI线程控件 在C#中，由于使用线程和调用UI的线程属于两个不同的线程，如果在线程中直接设置UI元素的属性，此时就会出现跨线程错误。    下面介绍两种解决方案  第一种：使用控件自带的Invoke或者BeginInvoke方法。 Task.Factory.StartNew(() => { this.button1.Invoke(new Action(() => { this.button1.Text = hello world; })
多线程高并发，java三大框架教程
m0_57699613的博客
07-23 493
阿里系的lazada一面现场（50min） ①sync的底层实现，锁优化，和lock的对⽐等 ②jvm参数调优详细过程，到为什么这么设置，好处，⼀些gc场景，如何去分析gc⽇志 ③redis数据结构，使⽤场景，微博场景使⽤redis如何去设计⽤户关系 ④线程池参数设定，为什么这么设定，有什么作⽤？7⼤参数 ⑤spring的循环依赖如何解决？为什么要三级缓存？ ⑥优先级队列的底层原理？ ⑦算法题：k路链表归并 ⑧算法题：数组最长子序列 ⑨ConcurrentHashMap的底层实现原理 ⑩你线上问题解决经验是
细节决定成败（一）
qq_41257365的博客
08-12 462
ScheduledThreadPool 执行周期性任务,假设某次出现了异常,周期任务还会继续吗？ 查看ScheduledExecutorService接口里的scheduleWithFixedDelay方法的jdk文档，有描述如下： If any execution of the task encounters an exception, subsequent executions are suppressed. 如果在任务的执行中遇到异常，后续执行被取消。 ScheduledThreadPoolExecu
java大数据、多线程及高并发的处理方案
qq_40660283的博客
08-04 680
java大数据、多线程及高并发的处理方案一、数据量太大获取缓慢怎么办？ 一、数据量太大获取缓慢怎么办？ 貌似这个问题在所有开发的应用系统中都会碰到这个问题，随着时间的推移，由于需求的不断演变，项目的数据量日渐增多，功能上的效率问题也会逐步显露出来，例如统计报表、查询下载、地图渲染等功能模块，当这些功能涉及到几十张表甚至上百张表时，不难想象一次性获取所有数据的时候系统将会变得异常缓慢。 1、首先从需求的设计和代码层次出发 优化我们写的代码，减少没必要的资源浪费。例如频繁地使用new对象的方式以及if else
Java总复习(一)——JavaSE基础
菜鸟的博客
10-03 193
Java概述 体系结构 JRE：Java核心类库 JVM：Java虚拟机 JDK：包含JRE和JVM，以及其他Java命令与工具(如java、javadoc、javac等) Java最大特点 跨平台：Java文件编译后是class文件，class文件符合Java虚拟机规范，每个平台都有一套JVM，class依赖与JVM而不是操作系统 Java数据类型 8种基本数据类型：byte、short、int、long、float、double、char、boolean 引用数据类型：数组、类对象、枚举、注解
C++ 线程暂停、继续
12-18
Vs2019 M'FC 创建的工程，模拟线程暂停、继续和退出
火车票订票系统模拟 (C 语言)
07-19
模拟火车票订票系统，分为用户端和客户端，支持相应的火车票管理系统操作.... 分模块写成 全C语言 界面友好......
java多线程并发及集合框架面试题
11-24
这是一个关于java面试的技术文档，里面包含一个中等难度的面试编程题，主要覆盖的java技术范围是JAVA集合框架和多线程并发，文档中有题目的清晰描述并附有完整的实现代码，同时还包括相关技术点的解析，适合java求职者和对java技术研究爱好者。
ｊａｖａ线程
09-28
程研究了线程的基础知识— 线程是什么、线程为什么有用以及怎么开始编写使用线程的简单 程序。 我们还将研究更复杂的、使用线程的应用程序的基本构件— 如何在线程之间交换数据、如何控制 线程以及线程如何互相通信。
Java多线程之并发工具类
12-22
一、总论：在JDK中提供了几种并发工具类 　　1）CountDownLatch（同步倒数计数器：等待多线程（或者多步骤）完成） 　　2）CyclicBarrier（循环屏障：同步屏障） 　　3）Semaphore(信号量：控制并发进程数) 　　主要参考资料：java并发编程的艺术、Java并发——同步工具类 　　二、CountDownLatch（同步倒数计数器）–不仅仅用于多线程 　　1.作用：允许一个或多个线程等待其他线程完成操作。 　　CountDownLatch的构造函数接受一个int类的参数作为计数器，如果你想等待N个节点完成，那这里传入N. 　　2.countDown
并发和多线程的编程的锁——漫谈
define_us的专栏
12-06 268
如果计算机只用来做一件事情，或者一件事情做完后再开始做第二件事情。那么根本不需要考虑什么并发。但是想象以下，我们的程序一定充斥着各种轮训（这就是我们大学时学的单片机，比如一会去检查下通讯就绪没有，一会又回去检查看门狗）。这无疑有一个基本要求，就是编程人员，哪怕是简简单单的一个业务，也必须熟悉计算机从硬件底层开始的所有知识，才能保证其可以正确处理各项操作的时序）。另外一方面，一旦我们有一个cpu负载...
JAVA线程知识点
卢楷方的博客
09-12 3685
java线程知识点大全 java线程知识点大全 1、 什么是线程？ 1、 什么是线程？ 线程是操作系统能够进行运算的最小单位，他包含在实际的运作单位里面，是进程中的实际运作单位。 程序员可以通过它进行多处理器编程，你可以使用多线程对运算密集型任务提速。比如，如果一个线程完成一个任务要100毫秒，那么用十个线程完成改任务只需10毫秒。Java在语言层面对多线程提供了...
细节决定成败！助你金九银十稳进大厂
天真爱器
05-31 57
前言 为什么要读Spring源码，有的人为了学习Spring中的先进思想，也有的人是为了更好的理解设计模式，当然也有很大一部分小伙伴是为了应付面试，Spring Bean的生命周期啦，Spring AOP的原理啦，Spring IoC的原理啦，应付面试，看几篇博客，对照着看看源码，应该就没什么问题了，但是如果想真正的玩懂Spring，需要花的时间真的很多，需要你沉下心，从最基础的看起，今天我们就来看看Spring中的基础——BeanDefinition。 01 并发宝典：面试专题 面试专题分为四个部分，分别
【极客时间】《Java并发编程实战》学习笔记
Mr.Cui的Java学习之路
10-01 1764
【极客时间】《Java并发编程实战》学习笔记
java多线程并发库使用
最新发布
01-27
Java多线程并发库是指Java语言为方便开发者使用多线程并发编程而提供的一组类和接口。它包含在Java SE的java.util.concurrent包中，提供了丰富的工具和组件，以支持并发编程。 Java多线程并发库的使用可以带来以下几个好处： 1. 提高并发性能：使用多线程并发库可以更好地利用多核处理器的能力，将计算密集型和I/O密集型任务分配给不同的线程，从而提高程序的并发性和响应能力。 2. 简化并发编程：多线程并发库提供了一系列的线程安全的集合类，如ConcurrentHashMap、ConcurrentLinkedQueue等，简化了共享数据的同步和访问控制，避免了手动编写复杂的同步代码。 3. 提供了高级的同步和通信机制：多线程并发库提供了更高级的同步机制，如锁、条件变量、信号量、倒计时门闩等，可以实现更细粒度的并发控制，避免了死锁和资源竞争问题。 4. 支持任务的执行和结果的返回：多线程并发库提供了Executor框架和Future接口，可以方便地提交任务和获取任务结果，更好地管理线程池，提高了任务的执行效率和结果的返回。 总之，Java多线程并发库的使用能够显著提高程序的并发性能，简化并发编程，提供更高级的同步和通信机制，更好地管理线程池，使开发者能够更轻松地编写高效、安全的多线程并发程序。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 6
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

虚妄狼

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值