Java多线程编程（三）——线程锁
卖票案例
某电影院目前正在上映国产大片，共有30张票，而它有3个窗口卖票，请设计一个程序模拟该电影院卖票
-
实现步骤
-
定义一个类Ticket实现Runnable接口，里面定义一个成员变量：private int tickets = 100;
-
在Ticket类中重写run()方法实现卖票，代码步骤如下
-
判断票数大于0，就卖票，并告知是哪个窗口卖的
-
卖了票之后，总票数要减1
-
票卖没了，线程停止
-
定义一个测试类Demo，里面有main方法，代码步骤如下
-
创建Ticket类的对象
-
创建三个Thread类的对象，把Ticket对象作为构造方法的参数，并给出对应的窗口名称
-
启动线程
-
如果不使用同步锁 Coding实现如下：
public class Ticket implements Runnable {
private int tickets = 100;
//在Ticket类中重写run()方法实现卖票，代码步骤如下
@Override
public void run() {
while (true) {
if(ticket <= 0){
//卖完了
break;
}else{
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
ticket--;
System.out.println(Thread.currentThread().getName() + "在卖票,还剩下" + ticket + "张票");
}
}
}
}
public class Demo {
public static void main(String[] args) {
//创建Ticket类的对象
Ticket st = new Ticket();
//创建三个Thread类的对象，把Ticket对象作为构造方法的参数，并给出对应的窗口名称
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个bug：
1.相同的票出现了多次、2.出现了负数的票
问题产生原因
线程执行的随机性导致的，Thread实例化对象t1，t2，t3对CPU的使用权的抢占是不确定的
可能在卖票过程中丢失cpu的执行权，（代码执行的每一行，如果不控制，CPU执行权都有可能被抢走）导致出现问题。
代码中sleep(100)，指代实际买票时出票导致的延迟，假设t1，t2，t3都在sleep，t1先抢到CPU执行权，执行ticket--后，ticket值是99
此时，执行权又被t2抢走，ticket再执行ticket--操作，ticket的值为98
又因为我们的程序是三个线程同时操作一个数据（ticket），所以打印出来的结果ticket的值都是98
出现负号票的原因也类似。
同步代码块解决数据安全问题
安全问题出现的条件
是多线程环境
有共享数据
有多条语句操作共享数据
如何解决多线程安全问题呢?
基本思想：让程序没有发生安全问题的环境
怎么实现呢?
把多条语句操作共享数据的代码给锁起来，让任意时刻只能有一个线程执行即可
Java提供了同步代码块的方式来解决
同步代码块格式：
synchronized(任意对象) {
多条语句操作共享数据的代码
}同步的好处和弊端
好处：解决了多线程的数据安全问题
弊端：当线程很多时，因为每个线程都会去判断同步上的锁，这是很耗费资源的，无形中会降低程序的运行效率
Coding：
public class demo {
public static void main(String[] args) {
Ticket ticket = new Ticket();
Thread t1 = new Thread(ticket);
Thread t2 = new Thread(ticket);
Thread t3 = new Thread(ticket);
t1.setName("窗口一");
t2.setName("窗口二");
t3.setName("窗口三");
t1.start();
t2.start();
t3.start();
}
}
public class Ticket implements Runnable{
private int ticket = 100;
private Object obj = new Object();
@Override
public void run() {
while(true) {
//使用同步解决
//注意synchronized()中的锁对象必须是唯一的
synchronized (obj) {
if(ticket == 0) {
break;
}
else {
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
ticket--;
System.out.println(Thread.currentThread().getName()
+ "在卖票，还剩下" + ticket);
}
}
}
}
}同步方法解决数据安全问题
同步方法的格式：
就是把synchronized关键字加到方法上
修饰符 synchronized 返回值类型 方法名(方法参数) {
方法体；
}同步方法和同步方法块的区别：
（1）同步代码块可以锁住指定代码，而同步代码块锁住方法里面的所有代码。
（2）同步代码块可以指定锁对象，同步方法不能指定锁对象，其锁对象是this。
public class MyRunnable implements Runnable {
private int ticketCount = 100;
@Override
public void run() {
while(true){
if("窗口一".equals(Thread.currentThread().getName())){
//同步方法
boolean result = synchronizedMthod();
if(result){
break;
}
}
if("窗口二".equals(Thread.currentThread().getName())){
//同步代码块
synchronized (this){
if(ticketCount == 0){
break;
}else{
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
ticketCount--;
System.out.println(Thread.currentThread().getName()
+ "在卖票,还剩下" + ticketCount + "张票");
}
}
}
}
}
private synchronized boolean synchronizedMthod() {
if(ticketCount == 0){
return true;
}else{
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
ticketCount--;
System.out.println(Thread.currentThread().getName()
+ "在卖票,还剩下" + ticketCount + "张票");
return false;
}
}
} public class Demo {
public static void main(String[] args) {
MyRunnable mr = new MyRunnable();
Thread t1 = new Thread(mr);
Thread t2 = new Thread(mr);
t1.setName("窗口一");
t2.setName("窗口二");
t1.start();
t2.start();
}
}上述案例，“窗口一”使用同步方法，“窗口二”使用同步代码块，效果是一致的。
同步静态方法
格式：
修饰符 static synchronized 返回值类型 方法名(方法参数) {
方法体；
}同步静态方法的锁对象？
类名.class
public class MyRunnable implements Runnable {
private static int ticketCount = 100;
@Override
public void run() {
while(true){
if("窗口一".equals(Thread.currentThread().getName())){
//同步方法
boolean result = synchronizedMthod();
if(result){
break;
}
}
if("窗口二".equals(Thread.currentThread().getName())){
//同步代码块
synchronized (MyRunnable.class){
if(ticketCount == 0){
break;
}else{
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
ticketCount--;
System.out.println(Thread.currentThread().getName()
+ "在卖票,还剩下" + ticketCount + "张票");
}
}
}
}
}
private static synchronized boolean synchronizedMthod() {
if(ticketCount == 0){
return true;
}else{
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
ticketCount--;
System.out.println(Thread.currentThread().getName()
+ "在卖票,还剩下" + ticketCount + "张票");
return false;
}
}
}Lock锁
虽然我们可以理解同步代码块和同步方法的锁对象问题，但是我们并没有直接看到在哪里加上了锁，在哪里释放了锁，为了更清晰的表达如何加锁和释放锁，JDK5以后提供了一个新的锁对象Lock。
Lock是接口不能直接实例化，这里采用它的实现类ReentrantLock来实例化
Lock提供了获得锁与释放锁的操作
void lock() //获得锁
void unlock() //释放锁 利用上面那个案例来演示如下
Coding：
import java.util.concurrent.locks.ReentrantLock;
public class Ticket implements Runnable {
//票的数量
private int ticket = 100;
private Object obj = new Object();
private ReentrantLock lock = new ReentrantLock();
@Override
public void run() {
while (true) {
//格式化的时候可以选中代码 ctrl + Alt + t
try {
lock.lock();
if (ticket <= 0) {
//卖完了
break;
} else {
Thread.sleep(100);
ticket--;
System.out.println(Thread.currentThread().getName()
+ "在卖票,还剩下" + ticket + "张票");
}
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
lock.unlock();
}
}
}
}
}public class Demo {
public static void main(String[] args) {
Ticket ticket = new Ticket();
Thread t1 = new Thread(ticket);
Thread t2 = new Thread(ticket);
Thread t3 = new Thread(ticket);
t1.setName("窗口一");
t2.setName("窗口二");
t3.setName("窗口三");
t1.start();
t2.start();
t3.start();
}
}这里使用了try-catch-finally，可以使用 Ctrl + Alt + T ，来设置。
https://blog.csdn.net/weixin_43715214/article/details/122375269?spm=1001.2014.3001.5501
