Java——线程之线程同步：同步代码块、同步方法、同步静态方法、线程安全类、Lock锁

Java——线程之线程同步

• 一、卖票案例
• 二、卖票案例的思考
• 三、卖票案例数据安全问题的解决
• 四、同步代码块
• 五、同步方法
• 六、同步静态方法
• 七、线程安全的类
• 八、Lock锁

一、卖票案例

1、需求

某电影院正在上映国产大片，共100张票，有3个窗口买票，设计一个程序模拟该电影院卖票

2、思路

① 定义一个SellTicket实现Runnable接口，里边有一个成员变量：private int tickets = 100;

②在SellTicket类中重写run()方法实现卖票，步骤如下：

• 判断票数大于0，就卖票，并告知是哪个窗口卖的
• 卖完票，总票数-1
• 票没有了，也可能有人来问，所以这里使用死循环让卖票的动作一致执行

③ 定义一个测试类SellTicketDemo，main方法的实现步骤如下：

• 创建SellTicket类对象
• 创建三个Thread类的对象，把SellTicket对象作为构造方法的参数，并给出对应的窗口名称
• 启动线程

3、代码实现

public class SellTicket implements Runnable {
    private int ticket = 100;

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

public class SellTicketDemo {
    public static void main(String[] args) {
        SellTicket st = new SellTicket();
        Thread th1 = new Thread(st, "窗口1");
        Thread th2 = new Thread(st, "窗口2");
        Thread th3 = new Thread(st, "窗口3");
        th1.start();
        th2.start();
        th3.start();
    }
}

4、运行结果

二、卖票案例的思考

在实际生活中，售票时出票也是需要时间的，所以在出售一张票的时候，需要一点时间的延迟，修改卖票的动作为每次出票时间100毫秒，用sleep()方法实现。卖票的代码如下：

public class SellTicket implements Runnable {
    private int ticket = 100;

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

上述代码会出现两个问题：

• 相同的票出现多次
• 出现了负数的票

这是由于线程执行的随机性导致的

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

1、为什么出现问题？

• 是否是多线程环境
• 是否有共享数据
• 是否有多条语句 *** 作共享数据

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

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

3、怎么实现？

• 把多条语句 *** 作共享数据的代码给锁起来，让任意时刻只能有一个线程执行即可
• Java提供了同步代码块的方式来解决

四、同步代码块

锁多条语句 *** 作共享数据，可以使用同步代码快实现，其格式如下：

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

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

使用同步代码块改进卖票案例代码如下：

public class SellTicket implements Runnable {
    private int ticket = 100;
    private Object obj = new Object();

    @Override
    public void run() {
        while (true) {
            synchronized (obj) {
                if (ticket > 0) {
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + "正在售卖第" + ticket + "张票");
                    ticket--;
                }
            }
        }
    }
}

同步的好处和弊端：

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

五、同步方法

• 将synchronized关键字加到方法上
• 格式：修饰符 synchronized 返回值类型 方法名(方法参数){ }
• 同步方法的锁对象是this

六、同步静态方法

• 把synchronized关键字加在静态方法上
• 格式：修饰符 static synchronized 返回值类型 方法名(方法参数){ }
• 同步静态方法的锁对象是类.class

七、线程安全的类

1、StringBuffer

• 线程安全，可变的字符序列
• 从JDK5开始，被StringBuilder代替。通常使用StringBuilder类，因为它支持所有相同的 *** 作，但它更快，因为它不执行同步

2、Vector

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

3、Hashtable

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

使用Collections类的一些方法可以返回由指定列表支持的同步（线程安全）列表

List<String> list = Collections.synchronizedList(new ArrayList<String>());

八、Lock锁

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

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

• void lock()：获得锁

• void unlock()：释放锁

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

• ReentrantLock()：创建一个ReentrantLock的实例

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

public class SellTicket implements Runnable {
    private int ticket = 100;
    private Lock lock = new ReentrantLock();

    @Override
    public void run() {
        while (true) {
            try {
                lock.lock();
                if (ticket > 0) {
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + "正在售卖第" + ticket + "张票");
                    ticket--;
                }
            } finally {
                lock.unlock();
            }
        }
    }
}