线程同步

当一个程序中有多个线程需要访问操作同一个数据时，数据可能会不安全，这时候就需要用到线程同步，线程同步一共有三种方法：

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

同步代码块实现线程同步：把需要同步执行的代码用synchronized(){}括起来,在{}里写需要同步的代码块，在()写一个对象，这个对象可以是任意对象

package thread;

public class Thread9 implements Runnable {
    private int ticket = 10;//模拟火车售票
    public static void main(String[] args) {
        Thread9 thread9 = new Thread9();
        Thread t1 = new Thread(thread9);//创建两个线程
        Thread t2 = new Thread(thread9);
        t1.start();//启动两个线程
        t2.start();
    }
    @Override
    public void run() {
        for (int i = 0; i <300 ; i++) {

               synchronized (this){//同步操作
                    if(ticket>0){
                         ticket--;
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("您购买的票剩余"+ticket+"张");
                }
             }
        }
    }
}

同步方法实现线程同步：synchronized也可以当修饰符使用，可以把它用在方法中，然后方法体里面写需要同步执行的内容，如上代码也可以简化成为以下代码：

package thread;

public class Thread10 implements Runnable {
    private int ticket = 10;
    public static void main(String[] args) {
        Thread10 thread10 = new Thread10();
        Thread t1 = new Thread(thread10);
        Thread t2 = new Thread(thread10);
        t1.start();
        t2.start();
    }
    @Override
    public void run() {
        for (int i = 0; i <300 ; i++) {
                Test();
        }
    }
    private synchronized void Test(){
            if(ticket>0){
                ticket--;
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("您购买的票剩余"+ticket+"张");
            }
        }
    }

lock实现同步

1. 在类里创建一个ReentrantLock的对象，互斥锁
2. 定义一个用于线程同步的不用synchronized修饰的方法，
3. 在想要锁定的地方使用对象.lock()的方法使用锁
4. 在想要结束的地方使用对象.unlock()的方法释放锁
5. 注意避免造成死锁，为了确保每次锁都能释放，可以加上finally语句进行控制

可以看出使用lock操作线程同步的方式比以上两种方式更加灵活

mport java.util.concurrent.locks.ReentrantLock;

public class Thread11 implements Runnable {
    private int ticket = 10;
    ReentrantLock Lock = new ReentrantLock();

    public static void main(String[] args) {
        Thread11 thread11 = new Thread11();
        Thread t1 = new Thread(thread11);
        Thread t2 = new Thread(thread11);

        t1.start();
        t2.start();
    }

    @Override
    public void run() {
        for (int i = 0; i < 300; i++) {
            Test();
        }
    }

    private void Test() {
        try {
            Lock.lock();
            if (ticket > 0) {
                ticket--;
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("您购买的票剩余" + ticket + "张");
            }
        } finally {
            Lock.unlock();
        }
    }
}