8---线程深入+Lambda表达式+Stream流

1、线程的深入

1、线程安全问题

（1）概念：

​ 多线程操作共享数据，导致共享数据错乱了。

（2）出现该问题的条件

​ 1.有多条线程
​ 2.有共享数据
​ 3.有多条语句操作共享数据

（3）解决方案：

​ 使用同步机制可以解决线程安全问题。（同步机制虽然解决了问题，但是效率将会变低）

​ 1.同步代码块
​ 2.同步方法
​ 3.Lock锁

2、解决方案之同步代码块

（1）使用格式：

synchronized (锁对象) {
    操作共享数据的代码;
}

​ 注意：任何对象都可以作为锁，而且这些锁都是同一把锁。

// 1.定义一个类实现Runnable接口,重写run方法,在run方法中编写卖票逻辑
public class SaleTickets implements Runnable {
   
    int ticketNumber = 100;
    Object obj = new Object(); // 创建一个对象

    @Override
    public void run() {
    // 3个线程执行run方法
        // 卖100张票的任务
        // 循环卖票
        String name = Thread.currentThread().getName();
        while (true) {
   
            // 用户注册
            // 用户登录
            // 用户浏览商品
            // 用户购买, 只锁操作共享数据的代码

            // 必须是同一把锁
            synchronized (obj) {
   //同步代码块要在while方法内部定义，否则就不会切换线程
            // synchronized (new Object()) {
   
                // 如果票数大于0,就卖一张票
                if (ticketNumber > 0) {
   
                    try {
   
                        Thread.sleep(10); // 此处让它睡一睡是为了更好地让其产生线程安全问题
                    } catch (InterruptedException e) {
   
                        e.printStackTrace();
                    }
                    ticketNumber--;
                    System.out.println(name + "卖了一张票,剩余 " + ticketNumber);
                } else {
   
                    // 没有票
                    break;
                }
            }
            Thread.yield(); // 尽量让CPU切换到其他线程
        }
    }
}

3、解决方案之同步方法

（1）使用格式

修饰符 synchronized 返回值类型 方法名() {
    操作共享数据的代码;
}

（2）实质：

​ 同步方法相当于方法中所有的内容均在同步代码块内。

​ a、【普通的同步方法】使用this作为锁

​ b、【静态同步方法】使用类名.class作为锁

​ （此时静态方法中没有this（因为使用类名调用））

// 1.定义一个类实现Runnable接口,重写run方法,在run方法中编写卖票逻辑
public class SaleTickets implements Runnable {
   
    static int ticketNumber = 100;

    @Override
    public void run() {
    // 3个线程执行run方法
        String name = Thread.currentThread().getName();//此语句一定要在run方法内部
        while (true) {
   
            // 如果票数大于0,就卖一张票
            saleTicket();
            if (ticketNumber == 0) {
   
                break;
            }
            Thread.yield(); // 尽量让CPU切换到其他线程
        }
    }

    // 有锁的线程能够进入同步方法,没有锁的线程在外面等待
    public synchronized void saleTicket() {
   
        if (ticketNumber > 0) {
   
            try {
   
                Thread.sleep(10); // 看问题
            } catch (InterruptedException e) {
   
                e.printStackTrace();
            }
            ticketNumber--;
            String name = Thread.currentThread().getName();
            System.out.println(name + "卖了一张票,剩余 " + ticketNumber);
        }
    }		

以上的同步方法相当于以下的同步代码块

// 同步方法相当于这样同步代码块
public void saleTicket2() {
   
    synchronized (this) {
   //这里地同步代码块运用的是调用该方法地对象作为锁
                         //实际上，同步方法就是这样的同步代码块。
        if (ticketNumber > 0) {
   
            try {
   
                Thread.sleep(10); // 看问题
            } catch (InterruptedException e) {
   
                e.printStackTrace();
            }
            ticketNumber--;
            String name = Thread.currentThread().getName();
            System.out.println(name + "卖了一张票,剩余 " + ticketNumber);
        }
    }
}

当以上的方法为静态方法的时候：

public synchronized static void saleTicket4() {
   
    if (ticketNumber > 0) {
   
        try {
   
            Thread.sleep(10); // 看问题
        } catch (InterruptedException e) {
   
            e.printStackTrace();
        }
        ticketNumber--;
        String name = Thread.currentThread().getName();
        System.out.println(name + "卖了一张票,剩余 " + ticketNumber);
    }
}

线程执行测试类

public class Demo03 {
   
    public static void main(String[] args) {
   
        SaleTickets st = new SaleTickets();
        // 2.创建多个线程,传入接口的实现类对象
        Thread t1 = new Thread(st, "窗口1");
        Thread t2 = new Thread(st, "窗口2");
        Thread t3 = new Thread(st, "窗口3");

        // 3.启动多个线程
        t1.start();
        t2.start();
        t3.start();
    }
}

4、解决方法之Lock

（1）概念：

​ Lock是一个接口，而Lock也有其实现类: ReentrantLock，叫做重入锁。

（2）实现类: ReentrantLock

​ 有两个方法：

void lock() 获得锁
void unlock() 释放锁

（3）Lock的使用格式：

lock.lock(); // 获得锁
try {
    操作共享资源的代码
} finally {//保证锁一定要释放
    lock.unlock(); // 释放锁
}

有锁的线程进入,没有锁的线程在外面等待

// 1.定义一个类实现Runnable接口,重写run方法,在run方法中编写卖票逻辑
public class SaleTickets implements Runnable {
   
    int ticketNumber = 100;
    Lock lock = new ReentrantLock();//多态

    @Override
    public void run() {
    // 3个线程执行run方法
        // 卖100张票的任务
        // 循环卖票
        String name = Thread.currentThread().getName();
        while (true) {
   
            // 如果票数大于0,就卖一张票
            // 获得锁, 锁住操作共享资源的代码
            lock.lock();
            try {
   
                if (ticketNumber > 0) {
   
                    try {
   
                        Thread.sleep(10); // 看问题
                    } catch (InterruptedException e) {
   
                        e.printStackTrace();
                    }
                    ticketNumber--;
                    System.out.println(name + "卖了一张票,剩余 " + ticketNumber);
                } else