线程的同步机制

方式一：同步代码块

synchronized(同步监视器){
	//需要被同步的代码
}

说明：1.操作共享数据的代码就是需要被同步的代码。
2.共享数据：多个线程共同操作的变量。比如：ticket就是共享数据
3.同步监视器，俗称锁。任何一个类的对象都可以充当锁。
要求：多个线程必须共用同一把锁。
补充：在实现Runnable接口创建多线程的方式中，我们可以考虑使用this充当同步监视器。

方式二：同步方法

如果操作共享数据的代码完整的声明在一个方法中，我们不妨将此方法声明为同步的。
关于同步方法的总结：
1.同步方法仍然涉及同步监视器，只是不需要我们显式的声明。
2.非静态的同步方法，同步监视器是：this
静态的同步方法，同步监视器是：当前类本 身。（类名.class）

代码演示

/**
 * @Date:CreatedIn 2020/6/8 21:38
 * @Description: 线程的安全问题（有共享数据的时候才会出现线程安全问题即多个线程处理同一部分数据）
 * 采用锁（同步监视器）
 * 同步监视器（锁）的要求：
 * 任意类的对象都可以作为锁，但是必须所有进程共用同一个锁
 */
public class Tickets {
    public static void main(String[] args) {
        Windows windows = new Windows();
        Thread thread1 = new Thread(windows);
        Thread thread2 = new Thread(windows);
        Thread thread3 = new Thread(windows);
        thread1.setName("窗口1:");
        thread2.setName("窗口2：");
        thread3.setName("窗口3：");
        thread1.start();
        thread2.start();
        thread3.start();
    }
}

class Windows implements Runnable {
    private int tickets = 100;

    @Override
    public void run() {

        //优缺点：在这个同步机制外面 ，多线程同步进行；
        //      到了这里，虽然安全的问题接菌了，但是相当于多线程变单线程了。。。。效率变慢
        //当要处理的部分害怕各线程之间由于抢占cpu造成的线程不安全问题
        //加上锁之后，当一个线程已经进来这个区域，哪怕发生了阻塞，别的线程也
        //会继续在外面等着这个线程结束以后才能进来执行
        while (true) {
            synchronized (Windows.class) { //此处便为锁
                if (tickets > 0) {
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + "卖出了：" + (tickets--));
                }else{
                    break;
                }
            }
        }
    }
}

方式三：Lock锁 — JDK5.0新增

synchronized与Lock的异同？
相同点：二者都可以解决线程的安全问题
不同点：synchronized机制在执行完相应的同步代码后，自动释放同步监视器；
Lock需要手动的启动同步（lock()），同时结束同步也需手动结束（unlock()）

代码演示

import java.util.concurrent.locks.ReentrantLock;

/**
 * @Date:CreatedIn 2020/6/9 13:13
 * @Description: 解决线程安全的第三种方法，JDK5.0以后新增的。
 * ReentrantLock使用lock()方法
 */
public class Tickets1 {

    public static void main(String[] args) {
        Windows1 windows1 = new Windows1();
        Thread thread1 = new Thread(windows1);
        Thread thread2 = new Thread(windows1);
        Thread thread3 = new Thread(windows1);
        thread1.start();
        thread2.start();
        thread3.start();

    }
}

class Windows1 implements Runnable{
private int tickets = 100;
private ReentrantLock lock = new ReentrantLock();//构造器如果选择true的话，说明各线程公平执行
                                                //谁先进来谁先执行，不填或者false的话各线程抢占。
    @Override
    public void run() {

        while (true) {
            try {
                lock.lock();//上锁
                if (tickets > 0) {
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }

                    System.out.println(Thread.currentThread().getName() + "卖票：" + (tickets--));
                } else {
                    break;
                }
            } finally {
                lock.unlock();//解锁
            }
        }
    }
}

补充

同步的利弊分析

优点：同步的方式解决了线程的安全问题。
缺点：操作同步代码时，只有一个线程参与，其他线程等待。相当于是一个单线程的过程，效率低。

死锁的理解

不同的线程分别占用对方需要的同步资源不放弃，都在等待对方放弃自己需要的同步资源，就形成了死锁。