目录
一、线程的同步（二）
同步机制释放锁的操作
不会释放锁的操作
线程的死锁问题
死锁
解决方法
Lock(锁)
使用Lock(锁)创建多线程步骤：
使用Lock解决窗口售票问题
synchronized与Lock的对比
练习
二、线程的通信
通过例题说明线程间的通信
wait()与notify()与notifyAll()
wait()
notify()
notifyAll()
说明
sleep()和wait()的异同
练习题
一、线程的同步（二）
同步机制释放锁的操作
1、当前线程的同步方法、同步代码块执行结束。
2、当前线程在同步代码块、同步方法中遇到break、return终止了该代码块、 该方法的继续执行。 3、当前线程在同步代码块、同步方法中出现了未处理的Error或Exception，导致异常结束。
4、当前线程在同步代码块、同步方法中执行了线程对象的wait()方法，当前线程暂停，并释放锁。
不会释放锁的操作
1、线程执行同步代码块或同步方法时，程序调用Thread.sleep()、 Thread.yield()方法暂停当前线程的执行
2、线程执行同步代码块时，其他线程调用了该线程的suspend()方法将该线程挂起，该线程不会释放锁（同步监视器）。应尽量避免使用suspend()和resume()来控制线程
线程的死锁问题
死锁
1、不同的线程分别占用对方需要的同步资源不放弃，都在等待对方放弃 自己需要的同步资源，就形成了线程的死锁
2、出现死锁后，不会出现异常，不会出现提示，只是所有的线程都处于 阻塞状态，无法继续
解决方法
1、专门的算法、原则
2、尽量减少同步资源的定义
3、尽量避免嵌套同步
Lock(锁)
从JDK 5.0开始，Java提供了更强大的线程同步机制——通过显式定义同 步锁对象来实现同步。同步锁使用Lock对象充当。
java.util.concurrent.locks.Lock接口是控制多个线程对共享资源进行访问的 工具。锁提供了对共享资源的独占访问，每次只能有一个线程对Lock对象加锁，线程开始访问共享资源之前应先获得Lock对象。
ReentrantLock 类实现了 Lock ，它拥有与 synchronized 相同的并发性和内存语义，在实现线程安全的控制中，比较常用的是ReentrantLock，可以显式加锁、释放锁。
使用Lock(锁)创建多线程步骤：
1）实例化ReentrantLock
2）调用锁定方法：lock()
3）调用解锁方法：unlock()
try{
xxx.lock();
//保证线程安全的代码
}finally{
xxx.unlock();
}
使用Lock解决窗口售票问题
import java.util.concurrent.locks.ReentrantLock;
public class LockTest {
public static void main(String[] args) {
Window w=new Window();
Thread t1=new Thread(w);
Thread t2=new Thread(w);
Thread t3=new Thread(w);
t1.setName("窗口1");
t2.setName("窗口2");
t3.setName("窗口3");
t1.start();
t2.start();
t3.start();
}
}
class Window implements Runnable{
private int ticket=100;
//1.实例化ReentrantLock
private ReentrantLock lock=new ReentrantLock();
@Override
public void run() {
while(true) {
try {
lock.lock();
if (ticket > 0) {
System.out.println(Thread.currentThread().getName() + ":，卖票，票号为：" + ticket);
ticket--;
} else {
break;
}
}finally {
lock.unlock();
}
}
}
}
synchronized与Lock的对比
相同点：二者都可以解决线程安全问题
不同点：
- Lock是显示锁，需手动开启和关闭锁；synchronized是隐式所，出了作用域自动释放
- Lock只有代码块锁；synchronized有代码块锁和方法锁
- 使用Lock锁，JVM将花费较少的时间来调度线程，性能更好。并且具有更好的扩展性（提供更所得子类）
练习
银行有一个账户。 有两个储户分别向同一个账户存3000元，每次存1000，存3次。每次存完打印账户余额。
/**
* @auther light
* @Description 银行有一个账户。
* 有两个储户分别向同一个账户存3000元，每次存1000，存3次。每次存完打
* 印账户余额
*
* 分析：
* 1.是否是多线程问题？ 是：两个储户线程
* 2.是否有共享数据？ 有：账户（或账户余额）
* 3.是否有线程安全问题？ 有
* 4.需要考虑如何解决线程安全问题？ 同步机制：三种方式
* @create 2022-11-19 15:14
*/
public class AccountTest {
public static void main(String[] args) {
Account acct=new Account(0);
Customer c1=new Customer(acct);
Customer c2=new Customer(acct);
c1.setName("甲");
c2.setName("乙");
c1.start();
c2.start();
}
}
class Account{
double balance;
public Account( double balance){
this.balance=balance;
}
//存钱
public synchronized void deposit(double amt){
if(amt>0){
balance+=amt;
// try {
// Thread.sleep(1000);
// } catch (InterruptedException e) {
// throw new RuntimeException(e);
// }
System.out.println(Thread.currentThread().getName()+"：存钱成功，余额为："+balance);
}
}
}
class Customer extends Thread{
Account acct;
public Customer(Account acct){
this.acct=acct;
}
@Override
public void run() {
for(int i=0;i<3;i++){
acct.deposit(1000);
}
}
}运行结果如下：
二、线程的通信
操作同一个资源时多个线程之间不断切换执行时所发出的信号
通过例题说明线程间的通信
线程通信例子：使用各个线程交替打印1-100 * 涉及到三个方法： * 1.wait():一旦执行此方法，当前线程就进入阻塞状态，并释放同步监视器 * 2.notify():一旦执行此方法，就会唤醒被wait的一个线程，如果有多个线程被wait，就唤醒优先级高的那个 * 3.notifyAll():一旦执行此方法就会唤醒所有被wait的线程 * * 说明： * 1.wait()、notify()、notifyAll()这三个方法只能使用在同步代码块或同步方法中 * 2.wait()、notify()、notifyAll()这三个方法的调用者必须是同步代码块或同步方法中的同步监视器。 * 3.wait()、notify()、notifyAll()这三个方法是定义在java.lang.Object类中的
public class ThreadCommunicationTest {
public static void main(String[] args) {
Number n=new Number();
Thread n1=new Thread(n);
Thread n2=new Thread(n);
n1.setName("线程1");
n2.setName("线程2");
n1.start();
n2.start();
}
}
class Number implements Runnable{
private int i=1;
@Override
public void run() {
synchronized (this) {
for (; i <= 100; ) {
notify();
try {
Thread.sleep(10);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
System.out.println(Thread.currentThread().getName() + ":打印输出：" + i);
i++;
try {
wait();
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
}
}
}部分运行结果为：
wait()与notify()与notifyAll()
wait()
令当前线程挂起并放弃CPU、同步资源并等待，使别的线程可访问并修改共享资源，而当前线程排队等候其他线程调用notify()或notifyAll()方法唤醒，唤醒后等待重新获得对监视器的所有权后才能继续执行。
notify()
唤醒正在排队等待同步资源的线程中优先级最高者结束等待
notifyAll()
唤醒正在排队等待资源的所有线程结束等待.
说明
- wait()、notify()、notifyAll()这三个方法只能使用在同步代码块或同步方法中
- .wait()、notify()、notifyAll()这三个方法的调用者必须是同步代码块或同步方法中的同步监视器。
- wait()、notify()、notifyAll()这三个方法是定义在java.lang.Object类中的
sleep()和wait()的异同
相同点：一旦执行方法，都可以使得当前线程进入阻塞状态
不同点：
- 两个方法声明的位置不同：sleep()声明在Thread类中；wait()声明在Object类中
- 调用的范围和要求不同：sleep()可以生命在任何需要的场景下；wait()只能声明在同步代码块或同步方法中
- 关于是否释放同步监视器：如果两个方法必须使用在同步代码块或同步方法中，sleep()不会释放同步监视器；wait()会释放同步监视器
练习题
生产者(Productor)将产品交给店员(Clerk)，而消费者(Customer)从店员处 取走产品，店员一次只能持有固定数量的产品(比如:20），如果生产者试图 生产更多的产品，店员会叫生产者停一下，如果店中有空位放产品了再通 知生产者继续生产；如果店中没有产品了，店员会告诉消费者等一下，如 果店中有产品了再通知消费者来取走产品。
问题分析：
* 1、是否是多线程问题：是，生产者线程，消费者线程
* 2、是否有共享数据：是，店员（或产品）
* 3、如何解决多线程问题：同步机制，三种方法
* 4、是否涉及线程通信：是
public class ProductTest {
public static void main(String[] args) {
Clerk c=new Clerk();
Producer p1=new Producer(c);
Customer c1=new Customer(c);
Thread t1=new Thread(p1);
Thread t2=new Thread(c1);
t1.setName("生产者1");
t2.setName("消费者1");
t1.start();
t2.start();
}
}
class Clerk {
private int product=0;
public synchronized void produceProduct() {
//生产者生产产品
if(product<20){
product++;
System.out.println(Thread.currentThread().getName()+":开始生产第 "+product+" 个产品");
notify();
}else{
try {
wait();
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
}
public synchronized void consumeProduct() {
//消费者消费产品
if(product>0){
System.out.println(Thread.currentThread().getName()+":开始消费第 "+product+" 个产品");
product--;
notify();
}else{
try {
wait();
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
}
}
class Producer implements Runnable{
Clerk clerk;
public Producer(Clerk clerk){
this.clerk=clerk;
}
@Override
public void run() {
System.out.println(Thread.currentThread().getName()+"开始生产产品...");
while(true){
try {
Thread.sleep(10);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
clerk.produceProduct();
}
}
}
class Customer implements Runnable{
Clerk clerk;
public Customer(Clerk clerk){
this.clerk=clerk;
}
@Override
public void run() {
System.out.println(Thread.currentThread().getName()+"开始消费产品...");
while(true){
try {
Thread.sleep(10);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
clerk.consumeProduct();
}
}
}
