本文通过电影院买票案例探讨Java线程同步问题，分析了同步代码块和同步方法的使用，同时介绍了线程安全的类如StringBuffer、Vector和Hashtable，并提到了Lock接口及ReentrantLock的应用。
1、买票案例
需求：电影院买票，共有100张票，有3个窗口买票，设计一个程序模拟电影院买票
思路：
1、定义一个类SellTicket实现Runnable接口，里面定义一个成员变量：private int tickets = 100;
2、在SellTicket类中重写run()方法实现卖票，代码步骤如下
A：判断票数大于0，就卖票，并告知是哪个窗口卖的
B：卖了票之后，总票数减1
C：票没有了，也可能有人来问，所以这里用死循环让卖票的动作一直执行
3、定义一个测试类SellTicketDemo，里面有main方法，代码步骤如下
A：创建SellTicket类的对象
B：创建3个Thread类的对象，把SellTicket对象作为构造方法的参数，并给出对应的窗口名称
C：启动线程
package Thread06;
//定义一个类SellTicket实现Runnable接口，里面定义一个成员变量：private int tickets = 100;
public class SellTicket implements Runnable {
private int tickets = 100;
//在SellTicket类中重写run()方法实现卖票，代码步骤如下
@Override
public void run() {
//A：判断票数大于0，就卖票，并告知是哪个窗口卖的
//B：卖了票之后，总票数减1
//C：票没有了，也可能有人来问，所以这里用死循环让卖票的动作一直执行
while (true) {
if (tickets > 0) {
System.out.println(Thread.currentThread().getName() + "正在出售第" + tickets + "张票");
tickets--;
}
}
}
}
-------------------------------------------------------------------------------
package Thread06;
/*
需求：电影院买票，共有100张票，有3个窗口买票，设计一个程序模拟电影院买票
思路：
1、定义一个类SellTicket实现Runnable接口，里面定义一个成员变量：private int tickets = 100;
2、在SellTicket类中重写run()方法实现卖票，代码步骤如下
A：判断票数大于0，就卖票，并告知是哪个窗口卖的
B：卖了票之后，总票数减1
C：票没有了，也可能有人来问，所以这里用死循环让卖票的动作一直执行
3、定义一个测试类SellTicketDemo，里面有main方法，代码步骤如下
A：创建SellTicket类的对象
B：创建3个Thread类的对象，把SellTicket对象作为构造方法的参数，并给出对应的窗口名称
C：启动线程
*/
public class SellTicketDemo {
public static void main(String[] args) {
//创建SellTicket类的对象
SellTicket st =new SellTicket();
//创建3个Thread类的对象，把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、买票案例的思考
实际生活中，售票时出票也是需要时间的，所以，在出售一张票的时候，需要一点时间的延迟，修改程序：每次出票时间100毫秒，用sleep()方法实现
买票出现了问题
- 相同的票出现了多次
- 出现了负数的票
问题原因：
- 线程执行的随机性导致的
package Thread07;
//定义一个类SellTicket实现Runnable接口，里面定义一个成员变量：private int tickets = 100;
public class SellTicket implements Runnable {
private int tickets = 100;
//在SellTicket类中重写run()方法实现卖票，代码步骤如下
@Override
public void run() {
//A：判断票数大于0，就卖票，并告知是哪个窗口卖的
//B：卖了票之后，总票数减1
//C：票没有了，也可能有人来问，所以这里用死循环让卖票的动作一直执行
//相同的票出现多次
// while (true) {
// //tickets = 100;
// //t1,t2,t3
// //假设t1线程抢到CPU的执行权
// if (tickets > 0) {
// //通过sleep()方法让线程休眠，让线程暂停执行,模拟出票时间
// try {
// Thread.sleep(100);
// //t1线程休息了100毫秒
// //t2线程抢到CPU的执行权，t2线程开始执行，执行到这里的时候，t2线程休息100毫秒
// //t3线程抢到CPU的执行权，t3线程开始执行，执行到这里的时候，t3线程休息100毫秒
// } catch (InterruptedException e) {
// e.printStackTrace();
// }
// //假设线程按照顺序醒过来
// //t1抢到CPU的执行权，在控制台输出：窗口1正在出售第100张票
// System.out.println(Thread.currentThread().getName() + "正在出售第" + tickets + "张票");
// //t2抢到CPU的执行权，在控制台输出：窗口2正在出售第100张票
// //t3抢到CPU的执行权，在控制台输出：窗口3正在出售第100张票
// tickets--;
// //如果这三个线程还是按照顺序来，这里就执行了3次--的操作，最终票就变成了97
// }
// }
//出现了负数的票
while (true) {
//tickets = 1;
//t1,t2,t3
//假设t1线程抢到CPU的执行权
if (tickets > 0) {
//通过sleep()方法让线程休眠，让线程暂停执行,模拟出票时间
try {
Thread.sleep(100);
//t1线程休息了100毫秒
//t2线程抢到CPU的执行权，t2线程开始执行，执行到这里的时候，t2线程休息100毫秒
//t3线程抢到CPU的执行权，t3线程开始执行，执行到这里的时候，t3线程休息100毫秒
} catch (InterruptedException e) {
e.printStackTrace();
}
//假设线程按照顺序醒过来
//t1抢到了CPU的执行权，在控制台输出：窗口1正在出售第1张票
//假设t1继续拥有CPU的执行权，就会执行tickets--;操作，tickets = 0;
//t2抢到了CPU的执行权，在控制台输出：窗口1正在出售第0张票
//假设t2继续拥有CPU的执行权，就会执行tickets--;操作，tickets = -1;
//t3抢到了CPU的执行权，在控制台输出：窗口1正在出售第-1张票
//假设t3继续拥有CPU的执行权，就会执行tickets--;操作，tickets = -2;
System.out.println(Thread.currentThread().getName() + "正在出售第" + tickets + "张票");
tickets--;
}
}
}
}
3、卖票案例数据安全问题的解决
为什么会出现问题？（这也是我们判断多线程程序是否会有数据安全问题的标准）
- 是否是多线程环境
- 是否有共享数据
- 是否有多条语句操作共享数据
如何解决多线程安全问题？
- 基本思想：让程序没有安全问题的环境
怎么实现？
- 把多条语句操作共享数据的代码给锁起来，让任意时刻只能有一个线程执行即可
- java提供了同步代码块的方式来解决
4、同步代码块
锁多条语句操作共享数据，可以使用同步代码块实现
- 格式：
synchronized(任意对象){
多条语句操作共享数据的代码
}
- synchronized(任意对象)：就相当于给代码加锁了，任意对象就可以看成是一把锁
同步的好处和弊端
- 好处：解决了多线程的数据安全问题
- 弊端：当线程很多时，因为每个线程都会去判断同步上的锁，这是很耗费资源的，无形中会降低程序的运行效率
package Thread08;
//定义一个类SellTicket实现Runnable接口，里面定义一个成员变量：private int tickets = 100;
public class SellTicket implements Runnable {
private int tickets = 100;
private Object obj = new Object();
//在SellTicket类中重写run()方法实现卖票，代码步骤如下
@Override
public void run() {
//A：判断票数大于0，就卖票，并告知是哪个窗口卖的
//B：卖了票之后，总票数减1
//C：票没有了，也可能有人来问，所以这里用死循环让卖票的动作一直执行
while (true) {
//tickets = 100;
//t1,t2,t3
//假设t1抢到了CPU的执行权
//假设t2抢到了CPU的执行权
synchronized (obj) {
//t1进来后就会把这段代码锁起来
if (tickets > 0) {
try {
Thread.sleep(100);
//t1休息100毫秒
} catch (InterruptedException e) {
e.printStackTrace();
}
//窗口1正在出售第100张票
System.out.println(Thread.currentThread().getName() + "正在出售第" + tickets + "张票");
tickets--;//tickets = 99;
}
}
//t1出来，把这段代码解锁被释放
}
}
}
---------------------------------------------------------------------------
package Thread08;
/*
需求：电影院买票，共有100张票，有3个窗口买票，设计一个程序模拟电影院买票
思路：
1、定义一个类SellTicket实现Runnable接口，里面定义一个成员变量：private int tickets = 100;
2、在SellTicket类中重写run()方法实现卖票，代码步骤如下
A：判断票数大于0，就卖票，并告知是哪个窗口卖的
B：卖了票之后，总票数减1
C：票没有了，也可能有人来问，所以这里用死循环让卖票的动作一直执行
3、定义一个测试类SellTicketDemo，里面有main方法，代码步骤如下
A：创建SellTicket类的对象
B：创建3个Thread类的对象，把SellTicket对象作为构造方法的参数，并给出对应的窗口名称
C：启动线程
*/
public class SellTicketDemo {
public static void main(String[] args) {
//创建SellTicket类的对象
SellTicket st =new SellTicket();
//创建3个Thread类的对象，把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();
}
}
5、同步方法
同步方法：就是把synchronized关键字加到方法上
- 格式：
修饰符 synchronized 返回值类型 方法名(方法参数){ }
同步方法的锁对象是什么？
- this
同步静态方法：就是把synchronized关键字加到静态方法上
- 格式：
修饰符 static synchronized 返回值类型 方法名(方法参数) { }
同步静态方法的锁对象是什么？
- 类名.class
package Thread09;
//定义一个类SellTicket实现Runnable接口，里面定义一个成员变量：private int tickets = 100;
public class SellTicket implements Runnable {
// private int tickets = 100;
private static int tickets = 100;
private Object obj = new Object();
private int x = 0;
//在SellTicket类中重写run()方法实现卖票，代码步骤如下
@Override
public void run() {
//A：判断票数大于0，就卖票，并告知是哪个窗口卖的
//B：卖了票之后，总票数减1
//C：票没有了，也可能有人来问，所以这里用死循环让卖票的动作一直执行
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--;
}
}
} 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--;
}
}
}
6、线程安全的类
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 集合框架Java Collections FrameworkJava 集合框架的成员。与新的集合实现不同，Hashtable是同步的。如果不需要线程安全实现，建议使用 HashMap 代替 。如果需要线程安全的高度并发实现，则建议使用 ConcurrentHashMap 代替
package Thread10;
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<>();
ArrayList<String> array = new ArrayList<String>();
Hashtable<String, String> ht = new Hashtable<>();
HashMap<String, String> hm = new HashMap<String ,String>();
//static <T> List<T> synchronizedList(List<T> list):返回由指定列表支持的同步（线程安全）列表
List<String> list = Collections.synchronizedList(new ArrayList<String>());
}
}
6、Lock锁
虽然我们可以理解同步代码块和同步方法的锁对象问题，但是我们并没有直接看到在哪里加上了锁，在哪里释放了锁，为了更清晰的表达如何加锁和释放锁，JDK5以后提供了一个新的锁对象Lock
Lock实现提供比使用synchronized方法和语句可以获得更广泛的锁定操作
Lock中提供了获得锁和释放锁的方法
- void lock():获得锁
- void unlock():释放锁
Lock是接口不能直接实例化，这里采用它的实现类ReentrantLock来实例化
ReentrantLock的构造方法
- ReentrantLock():创建一个ReentrantLock的实例
package Thread11;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
/*
Lock中提供了获得锁和释放锁的方法
void lock():获得锁
void unlock():释放锁
Lock是接口不能直接实例化，这里采用它的实现类ReentrantLock来实例化
ReentrantLock():创建一个ReentrantLock的实例
*/
public class SellTicket 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();
}
}
}
}
扫一扫
1294
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
