JavaSE-20.2.3【线程同步：线程安全的类、Lock锁】

package day11.lesson2;

import java.util.*;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/*
2.5 线程安全的类

    StringBuffer
        线程安全，可变的字符序列
        从版本JDK 5开始，被StringBuilder 替代。通常应该使用StringBuilder类，因为它支持所有相同的操作，但它更快，因为它不执行同步

    Vector
        从Java 2平台v1.2开始，该类改进了List接口，使其成为Java Collections Framework的成员。与新的集合实现不同， Vector被同步。 如果不需要线程安全的实现，建议使用ArrayList代替Vector

    Hashtable
        该类实现了一个哈希表，它将键映射到值。任何非null对象都可以用作键或者值
        从Java 2平台v1.2开始，该类进行了改进，实现了Map接口，使其成为Java Collections Framework的成员。与新的集合实现不同， Hashtable被同步。 如果不需要线程安全的实现，建议使用HashMap代替Hashtable

2.6 Lock锁

    虽然我们可以理解同步代码块和同步方法的锁对象问题，但是我们并没有直接看到在哪里加上了锁，在哪里释放了锁，
    为了更清晰的表达如何加锁和释放锁，JDK5以后提供了一个新的锁对象Lock。
    Lock锁实现提供比使用synchronized方法和语句可以获得更广泛的锁定操作
    加锁解锁方法
        void lock() 获得锁
        void unlock() 释放锁

    Lock是接口不能直接实例化，这里采用它的实现类ReentrantLock来实例化。
    ReentrantLock构造方法
        ReentrantLock() 创建一个ReentrantLock的实例
 */
public class SellTicket4 implements Runnable{

    private int tickets = 100;
    private Lock lock = new ReentrantLock();

    @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 + "张票");
                    tickets--;
                }
            }finally {
                lock.unlock(); //释放锁
            }
        }
    }
}

class SellTicketDemo4{
    public static void main(String[] args) {
//        test25();
        test26();
    }

    private static void test26() {
        SellTicket4 st = new SellTicket4();

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

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

    private static void test25() {
//        StringBuffer线程安全，StringBuilder线程不安全
        StringBuffer sb = new StringBuffer();
        StringBuilder sb2 = new StringBuilder();

//        Vector线程安全，ArrayList线程不安全
        Vector<String> v = new Vector<>();
        ArrayList<String> arrayList = new ArrayList<>();

//        Hashtable线程安全，HashMap线程不安全
        Hashtable<String, String> ht = new Hashtable<>();
        HashMap<String, String> hm = new HashMap<>();

        //通常对于StringBuffer和StringBuilder来说，当需要线程安全情况下，我们选择StringBuffer
        //而对于列表、集合等，我们不会选择 Vector和Hashtable，而是通过Collections集合类中的线程安全方法
        List<String> list = Collections.synchronizedList(new ArrayList<String>()); //返回由指定列表支持的同步（线程安全）列表
        Set<String> set = Collections.synchronizedSet(new HashSet<>()); //返回由指定集合支持的同步（线程安全）集
        Map<String, String> map = Collections.synchronizedMap(new HashMap<>()); //返回由指定集合支持的同步（线程安全）集合
    }
}