2、线程同步

买票案例

    package com.it_06;
/*
    需求：
        某电影院目前正在上映国产大片，共有100张票，而他有三个窗口买票请设计一个程序模拟该电影院买票

    思路：
        1、定义一个类SellTicket实现Runnable接口，里面定义一个成员变量：private int tickets = 100;
        2、在SellTicket类中重写run()方法实现买票，代码步骤如下
            A:判断票数大于0，就买票，并告知是那个窗口卖的
            B:买了票之后总票数要-1
            C:票没有了也可能有人来问，所以这里用死循环让买票的动作一直执行
        3、定义一个测试类SellTicketDemo。里面有main方法，代码步骤如下
            A:创建SellTicket类对象
            B:创建三个Thread类的对象，把SellTicket对象作为构造方法的参数，并给出对应窗口名称
            C:启动线程
 */
public class SellTicket implements Runnable {
    private int tickets = 100;

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

    package com.it_06;

public class SellTicketDemo {
    public static void main(String[] args) {
        SellTicket st = new SellTicket();
        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买票案例的思考

之前的电影院买票程序，好像没有什么问题，但是在实际生活中，售票出票也是有时间的，所以，在出售一张票的时候需要一点时间的延迟，接下来模拟买票的动作：每次出票时间100ms，用sleep()方法实现

买票出现了问题

*相同的票出现了多次

*出现了负数的票

问题原因：

*线程执行的随机性导致 

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

为什么出现问题？（这也是我们判断多线程程序是否会有数据安全问题的标准）

*是否是多线程环境

*是否有共享数据

*是否有多条语句操作共享数据

如何解决多线程安全问题？

*基本思想：让程序没有安全问题环境

怎么实现？

*把多条语句操作共享数据的代码给锁起来，让任意时刻只能有一个进程执行即可

*Java提供了同步代码块的方式来解决

2.3同步代码块

锁多条语句操作共享数据，可以使用同步代码块实现

*格式：
    synchronized(任意对象){
    多条语句操作共享数据代码
}
*synchronized(任意对象)：相当于给代码加锁了，任意对象就可以看成是一把锁

同步的好处和弊端

*好处：解决了多线程的数据安全问题

*弊端：当线程很多时，因为每个线程都会去判断同步上的锁，这是很耗费资源的无形中会降低程序的运行效率

2.4同步方法

同步方法：就是把synchronized关键字加到方法上
*格式:
    修饰符 synchronized 返回值类型 方法名 (方法参数){ }
同步方法的锁对象是什么呢？
    *this
同步静态方法：就是把 synchronized 关键字加到静态方法上
    *格式：
    修饰符 static synchronized 返回值类型 方法名(方法参数){ }
同步静态方法的锁对象是什么呢？
    *类名.class //反射涉及到

//买票
package com.it_09;

public class SellTicket implements Runnable {
//    private int tickets = 100;//cpu太好需要调高票数
    private static int tickets = 100;
    private Object obj = new Object();
    private int x = 0;

    @Override
    public void run() {
        while (true) {
            //线程锁
            if (x % 2 == 0) {
//                synchronized (obj) {
//                synchronized (this) {
                synchronized (SellTicket.class) {
                    if (tickets > 0) {
                        try {
                            Thread.sleep(100);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        System.out.println(Thread.currentThread().getName() + "正在出售第" + tickets + "张票");
                        tickets--;
                    }
                }
                //t1出来了，这段代码的锁就被释放了
            } else {
//                synchronized (obj) {
//                    if (tickets > 0) {
//                        try {
//                            Thread.sleep(100);
//                        } catch (InterruptedException e) {
//                            e.printStackTrace();
//                        }
//                        System.out.println(Thread.currentThread().getName() + "正在出售第" + tickets + "张票");
//                        tickets--;
//                    }
//                }
                sellTicket();
            }
            x++;
        }
    }

    //    private void sellTicket() {
//        synchronized (obj) {
//            if (tickets > 0) {
//                try {
//                    Thread.sleep(100);
//                } catch (InterruptedException e) {
//                    e.printStackTrace();
//                }
//                System.out.println(Thread.currentThread().getName() + "正在出售第" + tickets + "张票");
//                tickets--;
//            }
//        }
//    }
    //普通方法
//    private synchronized void sellTicket() {
//        if (tickets > 0) {
//            try {
//                Thread.sleep(100);
//            } catch (InterruptedException e) {
//                e.printStackTrace();
//            }
//            System.out.println(Thread.currentThread().getName() + "正在出售第" + tickets + "张票");
//            tickets--;
//        }
//    }
    private static synchronized void sellTicket() {
        if (tickets > 0) {
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "正在出售第" + tickets + "张票");
            tickets--;
        }
    }

}

2.5线程安全的类

StringBuilder:
	*线程安全，可变的字符序列
    *从版本JDK5开始，被 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代替Hashtaqble     

package com.it_10;

import java.util.*;

/*
    线程安全类
        StringBuffer
        Vector
        Hashtable
 */
public class ThreadDemo {
    public static void main(String[] args) {
        StringBuffer sb1 = new StringBuffer();//常使用
        StringBuilder sb2 = new StringBuilder();

        Vector<String> v = new Vector<String>();//被Collections替代
        ArrayList<String> array = new ArrayList<String>();

        Hashtable<String,String> ht = new Hashtable<String,String>();//被Collections替代
        HashMap<String,String> hm = new HashMap<String,String>();

        //static <T> List<T> synchronized (List<T> list)返回由指定列表同步（线程安全）列表
        List<String> list = Collections.synchronizedList(new ArrayList<String>());//Set,Map同理
    }
}

2.6 Lock锁

虽然我们可以理解同步代码块和同步方法的锁对象问题，但是我们并没有直接看到在哪里上了锁，在哪里释放了锁，为了更清晰地表达如何加锁和释放锁，JDK5提供了一个新的锁对象Lock

Lock实现提供比使用synchronized方法和语句可以获得更广泛的锁定操作

Lock中提供了获得锁和释放锁的方法

*void lock();获得锁
*void unlock();释放锁    

Lock是接口不能直接实例化，这里采用它的实现类 ReentrantLock 来实例化

ReentrantLock的构造方法

*ReentrantLock():创建一个ReentrantLock的实例