黑马程序员全套Java教程

黑马程序员全套Java教程_Java基础教程_多线程之线程同步（三十五）

- 案例：卖票
- 2.1 卖票案例的思考
- 2.2 卖票案例数据安全问题的解决
- 2.3 同步代码块
- 2.4 同步方法
- 2.5 线程安全的类
- 2.6 Lock锁

案例：卖票

需求：某电影院目前正在上映国产大片，共有100张票，而它有三个窗口卖票，请设计一个程序模拟该电影院卖票。
思路：
（1）定义一个类SellTickets实现Runable接口，里面定义一个成员变量：private int tickets = 100。
（2）在SellTickets类中重写run()实现卖票，代码步骤如下：
A：判断票数大于0，就卖票，并告知是哪个窗口卖的；
B：卖了票之后，也可能有人来问，所以这里使用死循环让卖票的动作一直执行；
C：票没有了，就可能有人来问，所以这里用死循环让卖票的动作一直执行。
（3）定义一个测试类SellTicketsDemo，里面有main方法，代码步骤如下：
A：创建SellTickets类的对象；
B：创建三个Thread类的对象，把SellTickets对象作为构造方法的参数，并给出对应的窗口名称；
C：启动线程。

public class SellTickets implements Runnable{
    private int tickets = 100;

    @Override
    public void run() {
        while (true) {
            if (tickets > 0) {
                System.out.println("窗口" + Thread.currentThread().getName() + "卖出第"+tickets+"张票");
                tickets--;
            }
        }
    }
}

    public static void main(String[] args) {
        SellTickets st = new SellTickets();

        Thread t1 = new Thread(st,"窗口1");
        Thread t2 = new Thread(st,"窗口2");
        Thread t3 = new Thread(st,"窗口3");

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

2.1 卖票案例的思考

刚才编写了电影院卖票程序，而在实际生活中，售票时出票也是需要时间的，所以，在出售一张票的时候，需要一点时间的延迟。接下来我们去修改卖票程序中卖票的动作：每次出票时间100毫秒，用sleep()方法实现。

public class SellTickets implements Runnable{
    private int tickets = 100;

    @Override
    public void run() {
        while (true) {
            if (tickets > 0) {
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("窗口" + Thread.currentThread().getName() + "卖出第"+tickets+"张票");
                tickets--;
            }
        }
    }
}

这时候却出现了两个异常的情形：
（1）相同的票出现了多次的原因；
（2）出现了负数的票。

相同的票出现了多次的原因分析：

public class SellTickets implements Runnable{
    private int tickets = 100;

    @Override
    public void run() {
        while (true) {
            if (tickets > 0) {
                try {
                    Thread.sleep(100);
                    //t1线程休息100ms
                    //t2线程抢到了CPU的执行权，t2线程就开始执行，执行到这里的时候，t2线程休息100ms
                    //t3线程抢到了CPU的执行权，t3线程就开始执行，执行到这里的时候，t3线程休息100ms
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                //假设线程按照循序醒过来
                //t1抢到CPU的执行权，在控制台输出：窗口1正在出售第100张票
                System.out.println("窗口" + Thread.currentThread().getName() + "卖出第"+tickets+"张票");
                //t1准备做tickets--,但假如刚好在这个时候,t2抢到CPU的执行权，在控制台输出：窗口2正在出售第100张票
                //t1准备做tickets--,但假如刚好在这个时候,t3抢到CPU的执行权，在控制台输出：窗口3正在出售第100张票
                tickets--;
                //如果三个线程还是按照顺序来,这里就执行了3次--的操作,最终票就变成了97
            }
        }
    }
}

出现了负数的票的原因分析：

public class SellTickets implements Runnable{
    private int tickets = 100;

    @Override
    public void run() {
        while (true) {
            //tickets = 1;
            //假设t1抢到了CPU的执行权
            if (tickets > 0) {
                try {
                    Thread.sleep(100);
                    //t1线程休息100ms
                    //t2线程抢到了CPU的执行权，t2线程就开始执行，执行到这里的时候，t2线程休息100ms
                    //t3线程抢到了CPU的执行权，t3线程就开始执行，执行到这里的时候，t3线程休息100ms
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                //假设线程按照循序醒过来
                //t1抢到CPU的执行权，在控制台输出：窗口1正在出售第1张票
                //假设t1继续拥有CPU的执行权，就会执行tickets--，tickets=0
                //t2抢到CPU的执行权，在控制台输出：窗口2正在出售第0张票
                //假设t2继续拥有CPU的执行权，就会执行tickets--，tickets=-1
                //t3抢到CPU的执行权，在控制台输出：窗口3正在出售第-1张票
                //假设t3继续拥有CPU的执行权，就会执行tickets--，tickets=-2
                System.out.println("窗口" + Thread.currentThread().getName() + "卖出第"+tickets+"张票");
                tickets--;
            }
        }
    }
}

问题的原因：线程执行的随机性导致的。

2.2 卖票案例数据安全问题的解决

出现问题的原因（这也是我们判断多线程是否会出现安全问题的标准）：
（1）是否是多线程环境；
（2）是否有共享数据；
（3）是否有多条语句操作共享数据。
解决多线程安全问题，要基于“让程序没有安全问题的环境”的思想，可以：
（1）把多条语句操作共享数据的代码给锁起来，让任意时刻只能有一个线程执行即可；
（2）Java提供了同步代码块的方式来解决。

2.3 同步代码块

锁多条语句操作共享数据，可以使用同步代码块实现：
（1）格式：

synchronized(任意对象){
	多条语句操作共享数据的代码
}

（2）synchronized(任意对象)：就相当于给代码加锁了，任意对象就可以看成是一把锁。

同步的好处和弊端：
（1）好处：解决了多线程的数据安全问题；
（2）弊端：当线程很多时，因为每个线程都会去判断同步上的锁，这是很耗费资源的，无形中会降低程序的运行效率。

public class SellTickets implements Runnable{
    private int tickets = 100;
    private Object obj = new Object();

    @Override
    public void run() {
        //tickets = 100;
        //t1,t2,t3
        //假设t1抢到了CPU执行权
        while (true) {
            //t1进来后，就会把这段代码给锁起来
            synchronized (obj){
                if (tickets > 0) {
                    try {
                        //t1休息100ms，休息这段时间其他线程可以抢到CPU执行权，但是有锁，进不来
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("窗口" + Thread.currentThread().getName() + "卖出第" + tickets + "张票");
                    tickets--;
                }
            }
            //t1出来了，这段代码就被释放了
        }
    }
}

2.4 同步方法

同步方法：就是把synchronized关键字加到方法上，其锁对象是this，格式：

修饰符 synchronized 返回值类型 方法名(方法参数){	}

public class SellTickets implements Runnable{
    private int tickets = 100;
    private int x = 0;

    @Override
    public void run() {
        while (true) {
            if (x % 2 == 0) {
                synchronized (this) {
                    if (tickets > 0) {
                        try {
                            Thread.sleep(100);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        System.out.println("窗口" + Thread.currentThread().getName() + "卖出第" + tickets + "张票");
                        tickets--;
                    }
                }
            }else {
                sellTickets();
            }
            x++;
        }
    }

    private synchronized void sellTickets() {
        if (tickets > 0) {
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("窗口" + Thread.currentThread().getName() + "卖出第" + tickets + "张票");
            tickets--;
        }
    }
}

同步静态方法：就是把synchronized关键字加到静态方法上，其锁对象是类名.class，格式：

修饰符 static synchronized 返回值类型 方法名(方法参数){	}

public class SellTickets implements Runnable{
    //private int tickets = 100;
    private static int tickets = 100;
    private int x = 0;

    @Override
    public void run() {
        while (true) {
            if (x % 2 == 0) {
                synchronized (SellTickets.class) {
                    if (tickets > 0) {
                        try {
                            Thread.sleep(100);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        System.out.println("窗口" + Thread.currentThread().getName() + "卖出第" + tickets + "张票");
                        tickets--;
                    }
                }
            }else {
                sellTickets();
            }
            x++;
        }
    }

    private static synchronized void sellTickets() {
        if (tickets > 0) {
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("窗口" + Thread.currentThread().getName() + "卖出第" + tickets + "张票");
            tickets--;
        }
    }
}

2.5 线程安全的类

原理：在这些类的成员方法添加synchronized关键字。
StringBuffer：
（1）线程安全，可变的字符序列；
（2）从版本JDK 5开始，被StringBuilder替代。通常应该使用StringBuilder类，因为它支持所有相同的操作，但它更快，因为它不执行同步。
Vetor：从Java 2平台v1.2开始，该类改进了List接口，使其称为Java Collections framework的成员。与新的集合实现不同，Vector被同步。如果不需要线程安全的实现，建议使用ArrayList替代Vector。
Hashtable：
（1）该类实现了一个哈希表，它将键映射到值。任何非null对象都可以用作键或者值；
（2）在Java 2平台v1.2开始，该类进行了改进，实现了Map接口，使其成为Java Collections framework的成员。与新的集合实现不同，Hashtable被同步。如果不需要线程安全的实现，建议使用HashMap代替Hashtable。

    public static void main(String[] args) {
        StringBuffer sb = new StringBuffer();
        StringBuilder sb2 = new StringBuilder();

        Vector v = new Vector<>();
        ArrayList al = new ArrayList<>();

        Hashtable ht = new Hashtable<>();
        HashMap hm = new HashMap<>();

        //static  list synchronizedList (List list) 返回由指定列表支持的同步（线程安全）列表
        List

黑马程序员全套Java教程

Java相关栏目本月热门文章