（一）目录

线程的优先级

守护线程

线程同步

线程并发协作

主要内容

（二）线程的优先级

1 什么是线程的优先级

每一个线程都是有优先级的，我们可以为每个线程定义线程的优先级，但是这并不能保证高优先级的线程会在低优先级的线程前执行。线程的优先级用数字表示，范围从 1 到 10，一个线程的缺省优先级是 5。

Java 的线程优先级调度会委托给操作系统去处理，所以与具体的操作系统优先级有关，如非特别需要，一般无需设置线程优先级。

注意：线程的优先级，不是说哪个线程优先执行，如果设置某个线程的优先级高。那就是有可能被执行的概率高。并不是优先执行。

2 线程优先级的使用

使用下列方法获得或设置线程对象的优先级。

int getPriority();
void setPriority(int newPriority);

具体代码：


class Priority implements Runnable{
private int num = 0;
private boolean flag = true;
@Override
public void run() {
while(this.flag){
System.out.println(Thread.currentThread().getName()+""+num++);
}
}
public void stop(){
this.flag = false;
}
}
public class PriorityThread {
public static void main(String[] args)throws Exception {
Priority p1 = new Priority();
Priority p2 = new Priority();
Thread t1 = new Thread(p1,"线程 1");
Thread t2 = new Thread(p2,"线程 2");
System.out.println(t1.getPriority());
//Thread.MAX_PRIORITY = 10
t1.setPriority(Thread.MAX_PRIORITY);
//Thread.MAX_PRIORITY = 1
t2.setPriority(Thread.MIN_PRIORITY);
t1.start();
t2.start();
Thread.sleep(1000);
p1.stop();
p2.stop();
}
}

（三）守护线程

1 什么是守护线程

在 Java 中有两类线程：

User Thread(用户线程)：就是应用程序里的自定义线程。
Daemon Thread(守护线程)：比如垃圾回收线程，就是最典型的守护线程。

守护线程（即 Daemon Thread），是一个服务线程，准确地来说就是服务其他的线程，这是它的作用，而其他的线程只有一种，那就是用户线程。

守护线程特点：守护线程会随着用户线程死亡而死亡。

2 守护线程与用户线程的区别

用户线程，不随着主线程的死亡而死亡。用户线程只有两种情况会死掉， 1 在 run 中异常终止。

2 正常把 run 执行完毕，线程死亡。守护线程，随着用户线程的死亡而死亡，当用户线程死亡守护线程也会随之死亡。

3 守护线程的使用

/**
* 守护线程类
*/
class Daemon implements Runnable{
@Override
public void run() {
for(int i=0;i<20;i++){
System.out.println(Thread.currentThread().getName()+""+i);
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
class UsersThread implements Runnable{
@Override
public void run() {
Thread t = new Thread(new Daemon(),"Daemon");
//将该线程设置为守护线程
t.setDaemon(true);
t.start();
for(int i=0;i<5;i++){
System.out.println(Thread.currentThread().getName()+""+i);
try {
Thread.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
public class DaemonThread {
public static void main(String[] args)throws Exception {
Thread t = new Thread(new UsersThread(),"UsersThread");
t.start();
Thread.sleep(1000);
System.out.println("主线程结束");
}
}

（四）线程同步

1.什么是线程同步

⑴ 线程冲突现象

⑵ 同步问题的提出

现实生活中，我们会遇到“同一个资源，多个人都想使用”的问题。比如：教室

里，只有一台电脑，多个人都想使用。天然的解决办法就是，在电脑旁边，大家排队。前一

人使用完后，后一人再使用。

⑶ 线程同步的概念

处理多线程问题时，多个线程访问同一个对象，并且某些线程还想修改这个对象。这时候，我们就需要用到“线程同步”。线程同步其实就是一种等待机制，多个需要同时访问此对象的线程进入这个对象的等待池形成队列，等待前面的线程使用完毕后，下一个线程再使用。

2 线程冲突案例演示

我们以银行取款经典案例来演示线程冲突现象。

银行取钱的基本流程基本上可以分为如下几个步骤。

（ 1 ）用户输入账户、密码，系统判断用户的账户、密码是否匹配。

（ 2 ）用户输入取款金额

（ 3 ）系统判断账户余额是否大于取款金额

（ 4 ）如果余额大于取款金额，则取钱成功；如果余额小于取款金额，则取钱失败。

代码：


/**
* 账户类
*/
class Account{
//账号
private String accountNo;
//账户的余额
private double balance;
public Account() {
}
public Account(String accountNo, double balance) {
this.accountNo = accountNo;
this.balance = balance;
}
public String getAccountNo() {
return accountNo;
}
public void setAccountNo(String accountNo) {
this.accountNo = accountNo;
}
 
public double getBalance() {
return balance;
}
public void setBalance(double balance) {
this.balance = balance;
}
}
/**
* 取款线程
*/
class DrawThread extends Thread{
//账户对象
private Account account;
//取款金额
private double drawMoney;
public DrawThread(String name,Account account,double drawMoney){
super(name);
this.account = account;
this.drawMoney = drawMoney;
}
/**
* 取款线程
*/
@Override
public void run() {
//判断当前账户余额是否大于或等于取款金额
if(this.account.getBalance() >= this.drawMoney){
System.out.println(this.getName()+" 取钱成功！吐出钞票："+this.drawMoney);
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
 
//更新账户余额
this.account.setBalance(this.account.getBalance()-
this.drawMoney);
System.out.println("\t 余额为："+this.account.getBalance());
}else{
System.out.println(this.getName()+" 取钱失败，余额不足");
}
}
}
public class DrawMoneyThread {
public static void main(String[] args) {
Account account = new Account("1234",1000);
new DrawThread("老公",account,800).start();
new DrawThread("老婆",account,800).start();
}
}

3 实现线程同步

由于同一进程的多个线程共享同一块存储空间，在带来方便的同时，也带来了访问冲突的问题。 Java 语言提供了专门机制以解决这种冲突，有效避免了同一个数据对象被多个线程同时访问造成的这种问题。这套机制就是 synchronized 关键字。

synchronized 语法结构：

synchronized(锁对象){

同步代码

}

synchronized 关键字使用时需要考虑的问题：

① 需要对那部分的代码在执行时具有线程互斥的能力(线程互斥：并行变串行)。

② 需要对哪些线程中的代码具有互斥能力(通过 synchronized 锁对象来决定)。

它包括两种用法：synchronized 方法和 synchronized 块。

synchronized 方法

通过在方法声明中加入 synchronized 关键字来声明，语法如下：

public synchronized void accessVal(int newVal);

synchronized 在方法声明时使用：放在范围操作符(public)之后,返回类型声明(void)

之前。这时同一个对象下 synchronized 方法在多线程中执行时，该方法是同步的，即一次

只能有一个线程进入该方法，其他线程要想在此时调用该方法，只能排队等候，当前线程(就

是在 synchronized 方法内部的线程)执行完该方法后，别的线程才能进入。

synchronized 块

synchronized 方法的缺陷：若将一个大的方法声明为 synchronized 将会大大影响效率。 Java 为我们提供了更好的解决办法，那就是 synchronized 块。块可以让我们精确地控制到具体的“成员变量”，缩小同步的范围，提高效率。

代码：

* 账户类
*/
class Account{
//账号
private String accountNo;
//账户的余额
private double balance;
public Account() {
}
public Account(String accountNo, double balance) {
this.accountNo = accountNo;
this.balance = balance;
}
public String getAccountNo() {
return accountNo;
}
public void setAccountNo(String accountNo) {
this.accountNo = accountNo;
}
public double getBalance() {
return balance;
}
public void setBalance(double balance) {
this.balance = balance;
}
}
/**
* 取款线程
*/
class DrawThread extends Thread{
//账户对象
 
private Account account;
//取款金额
private double drawMoney;
public DrawThread(String name,Account account,double drawMoney){
super(name);
this.account = account;
this.drawMoney = drawMoney;
}
/**
* 取款线程
*/
@Override
public void run() {
synchronized (this.account) {
//判断当前账户余额是否大于或等于取款金额
if (this.account.getBalance() >= this.drawMoney) {
System.out.println(this.getName() + " 取钱成功！吐出钞票：" + this.drawMoney);
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
//更新账户余额
this.account.setBalance(this.account.getBalance() -
this.drawMoney);
System.out.println("\t 余额为：" +
this.account.getBalance());
} else {
System.out.println(this.getName() + " 取钱失败，余额不足");
}
}
}
}
 
public class DrawMoneyThread {
public static void main(String[] args) {
Account account = new Account("1234",1000);
new DrawThread("老公",account,800).start();
new DrawThread("老婆",account,800).start();
}
}

5 线程同步的使用

5.1 使用 this 作为线程对象锁

在不同线程中，相同对象中的 synchronized 会互斥。

语法结构：

synchronized(this){

//同步代码

}

或

public synchronized void accessVal(int newVal){

//同步代码

}

5.2 使用字符串作为线程对象锁

所有线程在执行 synchronized 时都会同步。

语法结构：

synchronized(“字符串”){

//同步代码

}

5.3 使用 Class 作为线程对象锁

在不同线程中，拥有相同 Class 对象中的 synchronized 会互斥。

语法结构：

synchronized(XX.class){

//同步代码

}

或

synchronized public static void accessVal()

5.4 使用自定义对象作为线程对象锁

在不同线程中，拥有相同自定义对象中的 synchronized 会互斥。

语法结构：

synchronized(自定义对象){

//同步代码

}

6 死锁及解决方案

6.1 死锁的概念

“死锁”指的是：

多个线程各自占有一些共享资源，并且互相等待其他线程占有的资源才能进行，而导致两个或者多个线程都在等待对方释放资源，都停止执行的情形。

因此，某一个同步块需要同时拥有“两个以上对象的锁”时，就可能会发生“死锁” 的问题。比如，“化妆线程”需要同时拥有“镜子对象”、“口红对象”才能运行同步块。

那么，实际运行时，“小丫的化妆线程”拥有了“镜子对象”，“大丫的化妆线程”拥有了 “口红对象”，都在互相等待对方释放资源，才能化妆。这样，两个线程就形成了互相等待，无法继续运行的“死锁状态”。

6.3 死锁问题的解决

死锁是由于 “ 同步块需要同时持有多个对象锁造成 ” 的，要解决这个问题，思路很简单，

就是：同一个代码块，不要同时持有两个对象锁。

（五）线程并发协作(生产者/消费者模式)

多线程环境下，我们经常需要多个线程的并发和协作。这个时候，就需要了解一个重要的多线程并发协作模型“生产者/消费者模式”。

1 角色介绍

1.1 什么是生产者？

生产者指的是负责生产数据的模块。

1.2 什么是消费者？

消费者指的是负责处理数据的模块。

1.3 什么是缓冲区？

消费者不能直接使用生产者的数据，它们之间有个“缓冲区”。生产者将生产好的数据

放入“缓冲区”，消费者从“缓冲区”拿要处理的数据。

缓冲区是实现并发的核心，缓冲区的设置有两个好处：

实现线程的并发协作

有了缓冲区以后，生产者线程只需要往缓冲区里面放置数据，而不需要管消费者消费的情况；同样，消费者只需要从缓冲区拿数据处理即可，也不需要管生产者生产的情况。这样，就从逻辑上实现了“生产者线程”和“消费者线程”的分离，解除了生产者与消费者之间的耦合。

解决忙闲不均，提高效率

生产者生产数据慢时，缓冲区仍有数据，不影响消费者消费；消费者处理数据慢时，生产者仍然可以继续往缓冲区里面放置数据。

2 实现生产者与消费者模式

2.1 创建缓冲区

/**
* 定义馒头类
*/
class ManTou{
private int id;
public ManTou(int id){
this.id = id;
}
public int getId(){
return this.id;
}
}
/**
* 定义缓冲区类
*/
class SyncStack{
//定义存放馒头的盒子
private ManTou[] mt = new ManTou[10];
//定义操作盒子的索引
private int index;
/**
* 放馒头
*/
public synchronized void push(ManTou manTou){
//判断盒子是否已满
while(this.index == this.mt.length){
try {
/**
* 语法：wait(),该方法必须要在 synchronized 块中调用。
* wait 执行后，线程会将持有的对象锁释放，并进入阻塞状态，
* 其他需要该对象锁的线程就可以继续运行了。
*/
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
//唤醒取馒头的线程
/**
* 语法：该方法必须要在 synchronized 块中调用。
* 该方法会唤醒处于等待状态队列中的一个线程。
*/
this.notify();
this.mt[this.index] = manTou;
this.index++;
}
/**
* 取馒头
*/
public synchronized ManTou pop(){
while(this.index == 0){
try {
/**
* 语法：wait(),该方法必须要在 synchronized 块中调用。
* wait 执行后，线程会将持有的对象锁释放，并进入阻塞状态，
* 其他需要该对象锁的线程就可以继续运行了。
*/
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
this.notify();
this.index--;
return this.mt[this.index];
}
}

2.2 创建生产者消费者线程

/**
* 定义馒头类
*/
class ManTou{
private int id;
public ManTou(int id){
this.id = id;
}
public int getId(){
return this.id;
}
}
/**
* 定义缓冲区类
*/
class SyncStack{
//定义存放馒头的盒子
private ManTou[] mt = new ManTou[10];
//定义操作盒子的索引
private int index;
/**
* 放馒头
*/
public synchronized void push(ManTou manTou){
//判断盒子是否已满
while(this.index == this.mt.length){
try {
/**
* 语法：wait(),该方法必须要在 synchronized 块中调用。
* wait 执行后，线程会将持有的对象锁释放，并进入阻塞状态，
* 其他需要该对象锁的线程就可以继续运行了。
*/
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
//唤醒取馒头的线程
/**
* 语法：该方法必须要在 synchronized 块中调用。
 
* 该方法会唤醒处于等待状态队列中的一个线程。
*/
this.notify();
this.mt[this.index] = manTou;
this.index++;
}
/**
* 取馒头
*/
public synchronized ManTou pop(){
while(this.index == 0){
try {
/**
* 语法：wait(),该方法必须要在 synchronized 块中调用。
* wait 执行后，线程会将持有的对象锁释放，并进入阻塞状态，
* 其他需要该对象锁的线程就可以继续运行了。
*/
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
this.notify();
this.index--;
return this.mt[this.index];
}
}
/**
* 定义生产者线程类
*/
class ShengChan extends Thread{
private SyncStack ss;
public ShengChan(SyncStack ss){
this.ss = ss;
}
@Override
 
public void run() {
for(int i=0;i<10;i++){
System.out.println("生产馒头："+i);
ManTou manTou = new ManTou(i);
this.ss.push(manTou);
}
}
}
/**
* 定义消费者线程类
*/
class XiaoFei extends Thread{
private SyncStack ss;
public XiaoFei(SyncStack ss){
this.ss = ss;
}
@Override
public void run() {
for(int i=0;i<10;i++){
ManTou manTou = this.ss.pop();
System.out.println("消费馒头："+i);
}
}
}
public class ProduceThread {
public static void main(String[] args) {
SyncStack ss = new SyncStack();
new ShengChan(ss).start();
new XiaoFei(ss).start();
}
}

3 线程并发协作总结

线程并发协作（也叫线程通信）。

生产者消费者模式：

① 生产者和消费者共享同一个资源，并且生产者和消费者之间相互依赖，互为条件。

② 对于生产者，没有生产产品之前，消费者要进入等待状态。而生产了产品之后，又需要马上通知消费者消费。

③ 对于消费者，在消费之后，要通知生产者已经消费结束，需要继续生产新产品以供消费。

④ 在生产者消费者问题中，仅有 synchronized 是不够的。 synchronized 可阻止并发更新同一个共享资源，实现了同步但是 synchronized 不能用来实现不同线程之间的消息传递（通信）。

⑤ 那线程是通过哪些方法来进行消息传递（通信）的呢？见如下总结：

方法名	作用
final void wait()	表示线程一直等待，直到得到其它线程通知
void wait(long timeout)	线程等待指定毫秒参数的时间
final void wait(long timeout,int nanos)	线程等待指定毫秒、微秒的时间
final void notify()	唤醒一个处于等待状态的线程
final void notifyAll()	唤醒同一个对象上所有调用 wait()方法的线程，优先级别高的线程优先运行