系统化学习多线程(二)-线程同步-等待-通知

1.大纲

-------------------------学前必读----------------------------------

学习不能快速成功,但一定可以快速入门
整体课程思路:
1.实践为主,理论化偏少
2.课程笔记有完整的案例和代码,(为了学习效率)再开始之前我会简单粗暴的介绍知识点案例思路,
有基础的同学听了之后可以直接结合笔记写代码,
如果没听懂再向下看视频,我会手把手编写代码和演示测试结果;
3.重要提示,学编程和学游泳一样,多实践学习效率才高,理解才透彻;
4.编码功底差的建议每个案例代码写三遍,至于为什么...<<卖油翁>>...老祖宗的智慧

-------------------------------------------------------------------------

2.线程同步

1.synchronized锁住的是括号里的对象，而不是代码。
2.常用锁对象(this,字节码)
　　1. 当synchronized (TicketThread.class),程序执行正常,只用一份字节码,谁拥有字节码谁就有执行权
　　2. synchronized (lockObject),程序执行正常,因为整个应用上下文只有一个lockObject对象,谁拥有lockObject对象,谁就有执行权
　　3. synchronized (this),有重复售票的现象,this代表当前对象,拥有当前对象就拥有执行权,而在时间调用中我们创建了多个TicketThread对象,因此锁是无效的;
　　4. synchronized (num),有重复售票现象,因为num是变动的,如果有2个线程都是num=99那么只能有其中一个线程有执行权,
　　     但是如果num数不一样可以同时执行,这里为后面讲出售不同的班次的车票时提高锁的效率埋下伏笔

3.使用同步方法是，不需要手动添加同步监听对象，
　　如果是实例方法，那么默认的同步监听对象就是this，
　　如果是静态方法，默认的同步监听对象是类的字节码对象;
4.注意,当使用字节码锁时,使用了synchronized (TicketThread.class) 的地方都会被锁住,即使在不同的方法内;

5.ReentrantLock提供了比使用 synchronized 方法和语句可获得的更广泛的锁定操作,性能更高。

6.如果要对不同的数据加锁,应该怎么办,比如购票业务中只对同一班次的车票加锁.

需求:编写模拟售票程序,验证上面的结论

测试对象

package com.wfd360.thread;

import com.wfd360.thread.demo05Syn.TicketThread;
import org.junit.Test;

/**
 * @author 姿势帝-博客园
 * @address https://www.cnblogs.com/newAndHui/
 * @WeChat 851298348
 * @create 05/05 10:53
 * @description 线程同步
 * 1.同步代码块
 * synchronized锁住的是括号里的对象，而不是代码。
 * 2.同步方法
 * 使用同步方法是，不需要手动添加同步监听对象，
 * 如果是实例方法，那么默认的同步监听对象就是this，
 * 如果是静态方法，默认的同步监听对象是类的字节码对象;
 * 3.同步锁-ReentrantLock
 */
public class Test08Syn {
    /**
     * 测试:
     */
    @Test
    public void testTicketThread() throws InterruptedException {
        System.out.println("---test start-------");
        TicketThread thread1 = new TicketThread();
        thread1.setName("窗口1");
        TicketThread thread2 = new TicketThread();
        thread2.setName("窗口2");
        TicketThread thread3 = new TicketThread();
        thread3.setName("窗口3");
        // 开启线程
        thread1.start();
        thread2.start();
        thread3.start();
        Thread.sleep(10);
        //测试普通方法能否被调用
        //thread1.method1();
        System.out.println("==========等待售票============");
        Thread.sleep(10 * 1000);
        System.out.println("---test end-------");
    }
}

线程对象

package com.wfd360.thread.demo05Syn;

import java.util.concurrent.locks.ReentrantLock;

/**
 * @author 姿势帝-博客园
 * @address https://www.cnblogs.com/newAndHui/
 * @WeChat 851298348
 * @create 05/04 11:55
 * @description <p>
 * 模拟多线程售票
 * </p>
 */
public class TicketThread extends Thread {
    // 假定票总是100张
    private static Integer num = 100;
    // 锁对象
    private static Object lockObject = new Object();
    // 同步锁
    private static final ReentrantLock lock = new ReentrantLock();

    @Override
    public void run() {
        while (num > 0) {
            sellTicketLock();
        }
        System.out.println("===售票结束===");
    }

    /**
     * 当使用字节码锁时,使用了synchronized (TicketThread.class) 的地方都会被锁住,即使在不同的方法内
     */
    public void method1() {
        synchronized (TicketThread.class) {
            System.out.println("=======method1=============");
        }
    }

    /**
     * 同步代码块实现
     * 探讨synchronized锁的是什么?
     * synchronized锁住的是括号里的对象，而不是代码。
     * <p>
     * 1. 当synchronized (TicketThread.class),程序执行正常,只用一份字节码,谁拥有字节码谁就有执行权
     * 2. synchronized (lockObject),程序执行正常,因为整个应用上下文只有一个lockObject对象,谁拥有lockObject对象,谁就有执行权
     * 3. synchronized (this),有重复售票的现象,this代表当前对象,拥有当前对象就拥有执行权,而在时间调用中我们创建了多个TicketThread对象,因此锁是无效的;
     * 4. synchronized (num),有重复售票现象,因为num是变动的,如果有2个线程都是num=99那么只能有其中一个线程有执行权,
     * 但是如果num数不一样可以同时执行,这里为后面讲出售不同的班次的车票时提高锁的效率埋下伏笔
     */
    private void sellTicket() {
        synchronized (TicketThread.class) {
            if (num > 0) {
                // 获取线程名称
                String threadName = this.getName();
                System.out.println(threadName + "-正在出售第" + num + "张票");
                // 模拟售票耗时20毫秒
                try {
                    Thread.sleep(50);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                --num;
            }
        }
    }

    /**
     * 同步方法实现锁
     * 使用同步方法是，不需要手动添加同步监听对象，
     * 如果是实例方法，那么默认的同步监听对象就是this，
     * 如果是静态方法，默认的同步监听对象是类的字节码对象;
     * 1.实例方法 private synchronized void sellTicketSyn(),默认的同步监听对象就是this,只能锁住同一个对象,在当前使用会出现重复售票;
     * 2.静态方法 private static synchronized void sellTicketSyn(),同步监听对象是类的字节码对象,相当于全局锁;
     */
    private static void sellTicketSyn() {
        if (num > 0) {
            // 获取线程名称
            // String threadName = this.getName();
            String threadName = Thread.currentThread().getName();
            System.out.println(threadName + "-正在出售第" + num + "张票");
            // 模拟售票耗时20毫秒
            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            --num;
        }
    }

    /**
     * 同步锁-ReentrantLock
     * 1.加锁 lock.lock();
     * 2.必须手动释放锁 lock.unlock();
     */
    private void sellTicketLock() {
        // 对代码加锁
        lock.lock();
        try {
            if (num > 0) {
                // 获取线程名称
                // String threadName = this.getName();
                String threadName = Thread.currentThread().getName();
                System.out.println(threadName + "-同步锁正在出售第" + num + "张票");
                // 模拟售票耗时20毫秒
                try {
                    Thread.sleep(50);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                --num;
            }
        } finally {
            // 释放锁
            lock.unlock();
        }
    }
}

3.线程等待与唤醒

需求:模拟蓄水池流量限制,为了简单更明白的理解线程等待与通知,这里假定模型为极端情况,
假设蓄水池的正常水位是1000吨,当有水时每次取走水1000吨,当没有水时每次加入1000吨,让这两个动作交互进行
分析:
1.编写水池对象,并提供当前水位字段,取水方法,加水方法
/**
* 加水方法
* 1.synchronized 对同一个水池采用同步判定
* 2.判断是否有水,有水则等待(this.wait()),否则加水
* 3.加完水后进行通知(this.notify())
*/
/**
* 取水方法
* 1.synchronized 对同一个水池采用同步判定
* 2.判断是否有水,无水则等待(this.wait()),否则取水
* 3.取完水后进行通知(this.notify())
*/
2.编写2个线程,一个线程取水,一个线程加水
3.启动测试,创建一个水池对象,将对象分别传入取水线程和加水线程,并启动线程

实现代码

测试对象

package com.wfd360.thread;

import com.wfd360.thread.demo06Wait.AddPollThread;
import com.wfd360.thread.demo06Wait.Pool;
import com.wfd360.thread.demo06Wait.ReducePollThread;

/**
 * @author 姿势帝-博客园
 * @address https://www.cnblogs.com/newAndHui/
 * @WeChat 851298348
 * @create 05/05 3:18
 * @description <p>
 * 需求:模拟蓄水池流量限制,为了简单更明白的理解线程等待与通知,这里假定模型为极端情况,
 * 假设蓄水池的正常水位是1000吨,当有水时每次取走水1000吨,当没有水时每次加入1000吨,让这两个动作交互进行
 * 分析:
 * 1.编写水池对象,并提供当前水位字段,取水方法,加水方法
 * 2.编写2个线程,一个线程取水,一个线程加水
 * 3.启动测试,创建一个水池对象,将对象分别传入取水线程和加水线程
 *
 * </p>
 */
public class Test09Wait {
    /**
     * 测试加水取水交替进行,理解等待与通知
     *
     * @param args
     */
    public static void main(String[] args) {
        // 创建水池对象
        Pool pool = new Pool();
        pool.setNum(1000);
        // 创建加水线程,并启动
        new AddPollThread(pool, "加水线程").start();
        // 创建取水线程,并启动
        new ReducePollThread(pool, "取水线程").start();
    }
}

水池对象

package com.wfd360.thread.demo06Wait;

/**
 * @author 姿势帝-博客园
 * @address https://www.cnblogs.com/newAndHui/
 * @WeChat 851298348
 * @create 05/05 3:28
 * @description <p>
 * 水池对象
 * </p>
 */
public class Pool {
    // 水池编号
    private Integer id;
    // 水池当前水量
    private Integer num;

    /**
     * 加水方法
     * 1.synchronized 对同一个水池采用同步判定
     * 2.判断是否有水,有水则等待,否则加水
     * 3.加完水后进行通知
     */
    public synchronized void addPoll() throws Exception {
        String name = Thread.currentThread().getName();
        // 当水位大于或等于1000时,线程进入等待状态
        if (num >= 1000) {
            System.out.println(name + "-进入等待加水状态,num=" + num);
            this.wait();
        }
        System.out.println(name + "-准备加水,num=" + num);
        this.num += 1000;
        System.out.println(name + "-加水完成,num=" + num);
        this.notify();
    }
    /**
     * 取水方法
     * 1.synchronized 对同一个水池采用同步判定
     * 2.判断是否有水,无水则等待,否则取水
     * 3.取完水后进行通知
     */
    public synchronized void reducePoll() throws Exception {
        String name = Thread.currentThread().getName();
        // 当水位大于或等于1000时,线程进入等待状态
        if (num < 1000) {
            System.out.println(name + "-进入等待--取水--状态,num=" + num);
            this.wait();
        }
        System.out.println(name + "-准备--取水--,num=" + num);
        this.num -= 1000;
        System.out.println(name + "---取水--完成,num=" + num);
        this.notify();
    }

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public Integer getNum() {
        return num;
    }

    public void setNum(Integer num) {
        this.num = num;
    }
}

 取水线程

package com.wfd360.thread.demo06Wait;

/**
 * @author 姿势帝-博客园
 * @address https://www.cnblogs.com/newAndHui/
 * @WeChat 851298348
 * @create 05/05 3:41
 * @description
 */
public class ReducePollThread extends Thread {
    private Pool pool;

    // 创建线程必须传入水池对象
    public ReducePollThread(Pool pool,String name) {
        this.pool = pool;
        this.setName(name);
    }

    @Override
    public void run() {
        // 循环取水100次
        for (int i = 0; i < 100; i++) {
            try {
                pool.reducePoll();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
}

加水线程

package com.wfd360.thread.demo06Wait;

/**
 * @author 姿势帝-博客园
 * @address https://www.cnblogs.com/newAndHui/
 * @WeChat 851298348
 * @create 05/05 3:41
 * @description
 */
public class AddPollThread extends Thread {
    private Pool pool;

    // 创建线程必须传入水池对象
    public AddPollThread(Pool pool,String name) {
        this.pool = pool;
        // 设置线程名称
        this.setName(name);
    }

    @Override
    public void run() {
        // 循环加水100次
        for (int i = 0; i < 100; i++) {
            try {
                pool.addPoll();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
}

测试结果

 完美!

系统化的在线学习：点击进入学习