线程的同步

一.线程的安全问题：

1.问题：卖票过程中出现重票和错票问题(线程不安全问题)
2.出现原因：当某个线程的操作尚未完成时，其他线程的操作就参与进来。(即多个线程同时共用一块数据)
3.解决措施：当一个线程在操作共享数据时，其他线程不能参与进来(直到原线程操作完其他线程才可以参与进来)
该情况即使在原线程发生了阻塞也不会改变这种情况
4.在Java中通过同步机制来解决线程安全问题

 

二.同步代码块方法：

说明：1.操作共享数据的代码，即为需要被同步的代码(所包的代码不能多也不能少)
     2.共享数据：多个线程中共同操作的变量(本例即为ticket)
     3.同步监视器(锁)：任何一个类的对象都可以作为锁
       要求：多个线程必须共同使用同一把锁(否则无法保证线程安全)
       补充：可以考虑适用this.class来做锁
好处：较为简易的解决了线程安全问题。
坏处：将多线程转为单线程来解决问题，效率较低

1.同步代码块解决继承Thread类的线程安全问题

代码及解析：

class Window extends Thread {
    private static int ticket = 100;//所有同类对象共享static变量

    private static Object obj = new Object();//保证用同一把锁

    public void run() {
        while (true) {
            synchronized (obj) {
                if (ticket > 0) {
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                    System.out.println(getName() + "卖票,票号为:" + ticket);
                    ticket--;
                } else {
                    break;
                }
            }
        }
    }
}

2.解决Runnable接口的实现方式的线程安全问题：

class Window2 implements Runnable {
    private int ticket = 100;
    Object obj = new Object();
    @Override
    public void run() {
        while (true) {
            //方式一：同步代码块
            synchronized (obj) {
                if (ticket > 0) {
                    System.out.println(Thread.currentThread().getName() + "卖票,票号为:" + ticket);
                    ticket--;
                } else {
                    break;
                }
            }
        }
    }
}

 

三.同步方法

1.同步方法仍然设计到同步监视器(锁)，但不需要我们显示声明
2.静态方法的锁为this.class,非静态方法的锁为this

1.使用同步方法解决Thread类的继承问题

class Window4 extends Thread {
    private static int ticket = 100;//所有同类对象共享static变量

    private static Object obj = new Object();//保证用同一把锁

    public void run() {
        while (true) {

        }
    }

    private static synchronized void show() {//使用静态同步方法实现(静态保证锁相同(静态使锁设为当前对象的类))
        if (ticket > 0) {
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            System.out.println(Thread.currentThread().getName() + "卖票,票号为:" + ticket);
            ticket--;
        }
    }
}

 

2.解决Runnable接口的线程安全问题：

class Window3 implements Runnable {
    private int ticket = 100;
    Object obj = new Object();
    @Override
    public void run() {
        while (ticket > 0) {
            show();
        }
    }

    public synchronized void show() {//使用同步方法
        if (ticket > 0) {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            System.out.println(Thread.currentThread().getName() + "卖票,票号为:" + ticket);
            ticket--;
        }
    }
}

 

四.锁的添加

class Window implements Runnable {
    private int ticket = 100;
    //1.实例化ReentrantLock
    private ReentrantLock lock = new ReentrantLock(true);

    public void run() {
        try {
            //2.调用锁定方法lock()
            lock.lock();
            while (true) {
                if (ticket > 0) {
                    System.out.println(Thread.currentThread().getName() + "卖票,票号为:" + ticket);
                    ticket--;
                } else {
                    break;
                }
            }
        } finally {
            //3.调用解锁方法unlock()
            lock.unlock();
        }

    }
}

 

synchronized与Lock的不同点
    synchronized机制：在执行完对应的代码块后，自动的释放同步监视器
    Lock机制：需要手动的启动同步(Lock())，结束同步也需要手动的实现(Unlock())