Java多线程探究-线程同步

什么是线程同步

线程同步是解决多个线程同时对同一数据进行操作，而导致的数据破坏
就像前面我写的卖票的例子，就出现了卖出-1的票，这样就出现了问题

线程同步的方式

1. synchronized关键字

1.1 同步方法

在方便声明上加入synchronized，这样，这个方法就是同步了，每次只有一个线程可以执行方法的代码，如果这个线程没有离开方法，那么
其他线程只能处于阻塞状态，这样就保证了一次只有一个线程在操作数据

class MyRunnable implements   Runnable{
    private int ticket = 100;

    @Override
    public  void run(){
            salseTicket();
    }
    public synchronized void salseTicket(){
        while (true){
            if(ticket > 0){
                try {
                    Thread.sleep(5);
                    System.out.println("线程 "+Thread.currentThread().getName()+" sales "+ticket--);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

            }else{
                break;
            }
        }
    }

}
public class ThreadDemo {

    public static void main(String[] args) {
        MyRunnable runnable = new MyRunnable();
        Thread t1 = new Thread(runnable,"one");
        Thread t2 = new Thread(runnable,"two");
        Thread t3 = new Thread(runnable,"third");
        Thread t4 = new Thread(runnable,"four");
        t1.start();
        t2.start();
        t3.start();
        t4.start();
    }
}

1.2. 同步代码块

同步代码块不同与同步方法，同步代码块只对某一部分代码进行加锁，这样会比整个方法加锁效率要高
在我们的卖票程序主要是最ticke–这个操作不是原子操作，我们必须保证每个线程把打印和ticke–这两个过程都执行，才允许其他的
线程进来继续执行
同步代码块需要一个锁，这个锁是对象锁，对于要同步的线程，必须拥有的锁是一致的，这样才能保证同步
比如，下面的例子中的对象锁是this,这个this是MyRunnable的引用，只有一份，每个线程都拥有，所以可以做到同步

class MyRunnable implements Runnable {
    private int ticket = 100;

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

    public void salseTicket() {
        while (true) {
            synchronized (this) {//同步代码块
                if (ticket > 0) {
                    try {
                        Thread.sleep(5);
                        System.out.println("线程 " + Thread.currentThread().getName() + " sales " + ticket--);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                } else {
                    break;
                }
            }
        }
    }
}

试想下面的对象锁new Object(),这样尽管加了对象锁，但是个线程拥有的都是一个新的Object对象，那么这个锁机制就会失效，起不到同步的作用

synchronized (new Object()) {
    if (ticket > 0) {
        try {
            Thread.sleep(5);
            System.out.println("线程 " + Thread.currentThread().getName() + " sales " + ticket--);

        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    } else {
        break;
    }
}

类锁，除了对象锁意外，还有一种类锁，如果代码块所在的方法是静态方法，那么synchronized的锁应该是类，而不是this.众所周知，静态
方法是没有对象的this引用的,下面的程序就是一个类锁

public static  void salseTicket() {
    while (true) {
        synchronized (MyRunnable.class) {
            if (ticket > 0) {
                try {
                    Thread.sleep(5);
                    System.out.println("线程 " + Thread.currentThread().getName() + " sales " + ticket--);

                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            } else {
                break;
            }
        }
    }
}