二丶多线程的进阶一（锁）

1.线程的安全的性问题？

多个线程访问同一个数据的时候，就会操作线程的安全的问题，因为线程内部操作其实是先取值，然后修改，最后再更新内存中的数据。这样由于多个线程的切换就会导致线程安全的问题，比如我们的i++就不是线程安全。

1.线程的安全的原因：由于原子性被破坏。

2.如何避免线程安全的性的问题

1.synchronized

核心思想，对我们的资源进行加锁，当前只能有一个线程得到资源，从而保证数据原子性和安全性。

①使用方式1：修饰类对象

@Override
    public void run() {
        demo();
    }

    private void demo() {
        for (int i = 0; i < 1000; i++) {
            System.out.println("可以进入demo方法的线程名称————————" + Thread.currentThread().getName() + "_____" + i);
            synchronized (ThreadClassDemo.class) {
                System.out.println("可以进入system方法的线程名称******" + Thread.currentThread().getName() + "_____" + i);
            }
        }
    }

最好不要把synchronized用来修饰方法，因为这样会增大他的锁的范围。

②使用方式2：修饰对象

    private void demo() {
        for (int i = 0; i < 1000; i++) {
            System.out.println("可以进入demo方法的线程名称————————" + Thread.currentThread().getName() + "_____" + i);
            synchronized (this) {
                System.out.println("可以进入system方法的线程名称******" + Thread.currentThread().getName() + "_____" + i);
                try {
                    Thread.sleep(9999);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }

这里明现可以看出两个对象可以同时进去。

二丶使用synchronized关键字的原理

通过使用锁，我们在对象头中加锁，然后只有获取这个锁的线程才能访问被锁的数据，
存在对象头中的MAKE WORD

三丶锁的升级和条件

关于锁的升级和变化条件图

进入重量级锁且未获得锁的线程就会变成被阻塞状态。并随时监视锁是否被释放方便获得锁资源。

四丶线程的通信（wate,notify）

一个关于生产者消费者模型的线程通知：

生产者：

public class Product implements Runnable {
    /*
     * 消息队列
    * */

    private Queue<String> queue;

    private Integer size;

    public Product(Queue<String> queue,Integer size){
        this.queue = queue;
        this.size = size;
    }

    @Override
    public void run() {
        Integer num = 0;
        while (true){
            //对同一个对象加锁
            synchronized (queue){
                //如果队列达到最大，就不能生产，让此线程等待
                while (queue.size() == size){
                    System.out.println("生产队列达到最大");
                    try {
                        queue.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                System.out.println("生产者生产消息");
                queue.add("生产消息"+ ++num);
                queue.notify();
            }

        }
    }
}

消费者：

public class Consumer implements Runnable {
    /*
     * 消息队列
     * */

    private Queue<String> queue;

    private Integer size;

    public Consumer(Queue<String> queue,Integer size){
        this.queue = queue;
        this.size = size;
    }
    @Override
    public void run() {
        while (true){
            synchronized (queue){
                //如果消息队列不存在。就让消费者队列等待
                while (queue.isEmpty()){
                    try {
                        queue.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }

                //消费队列
                System.out.println("消费者消费————"+ queue.remove());
                //唤醒其他线程
                queue.notifyAll();
            }

        }
    }
}

测试代码：

public class Test {

    public static void main(String[] args) {
        Queue<String> queue = new LinkedList<>();
        Integer size = 10;
        Product product = new Product(queue, size);
        Consumer consumer = new Consumer(queue, size);
        new Thread(product,"生产者").start();
        new Thread(consumer,"消费者").start();

    }
}

这里重要的问题是主要锁的是同一个对象，才能进行两个对同一个队列的处理。

项目地址：https://gitee.com/wei_chen_1/multithreaded_learning.git