目录
线程同步机制
基本介绍
Java中的线程同步机制指的是多个线程之间共享数据的安全性问题。在多线程程序中，每一个线程都有自己的执行顺序和独立的内存空间，这样就会存在多个线程同时访问同一个共享数据的情况，容易导致数据不一致或者出现错误的结果。
Java提供了多种线程同步机制，其中比较常见的包括：
-
synchronized关键字：synchronized关键字可以修饰方法或代码块，它的作用是保证同一时刻只有一个线程可以执行被synchronized修饰的代码块或方法，其他线程需要等待当前线程执行完毕才能执行。
Synchronized
1.在多线程编程，些敏感数据不允许被多个线程同时访问，此时就使用同步访问技术，保证数据在任何同一时刻，最多有一个线程访问，以保证数据的完整性。
2也可以这里理解: 线程同步，即当有一个线程在对内存进行操作时，其他线程都不可以对这个内存地址进行操作，直到该线程完成操作，其他线程才能对该内存地址进行操作
同步具体方法-Synchronized
1.同步代码块
synchronized(对象){// 得到对象的锁，才能操作同步代码
// 需要被同步代码:
}2.synchronized还可以放在方法声明中，表示整个方法-为同步方法
public synchronized void m (String name){
//需要被同步的代码
}还记得我们之前写的那个模拟的售票系统吗，在当时我们还会出现超卖的情况，现在学习了线程同步机制的，那么就可以解决之前会出现超卖的问题了
代码演示：
实现方式也很简单，出现把我们之前写的代码，就是出售票的那一段，提取出来加上synchronized关键字在，在下面的代码中，我们在外面新写了一个方法，然后在该方法中，加上了synchronized关键字，然后在run方法中调用该方法即可
package com.syn;
/**
* 使用多线程，模拟三个窗口同时售票100张
*/
public class SellTicket {
public static void main(String[] args) {
//测试
// SellTicket01 sellTicket01 = new SellTicket01();
// SellTicket01 sellTicket02 = new SellTicket01();
// SellTicket01 sellTicket03 = new SellTicket01();
//
// //这里我们会出现超卖..
// sellTicket01.start();//启动售票线程
// sellTicket02.start();//启动售票线程
// sellTicket03.start();//启动售票线程
// System.out.println("===使用实现接口方式来售票=====");
// SellTicket02 sellTicket02 = new SellTicket02();
//
// new Thread(sellTicket02).start();//第1个线程-窗口
// new Thread(sellTicket02).start();//第2个线程-窗口
// new Thread(sellTicket02).start();//第3个线程-窗口
//测试一把
SellTicket03 sellTicket03 = new SellTicket03();
new Thread(sellTicket03).start();//第1个线程-窗口
new Thread(sellTicket03).start();//第2个线程-窗口
new Thread(sellTicket03).start();//第3个线程-窗口
}
}
//实现接口方式, 使用synchronized实现线程同步
class SellTicket03 implements Runnable {
private int ticketNum = 100;//让多个线程共享 ticketNum
private boolean loop = true;//控制run方法变量
Object object = new Object();
//同步方法（静态的）的锁为当前类本身
//解读
//1. public synchronized static void m1() {} 锁是加在 SellTicket03.class
//2. 如果在静态方法中，实现一个同步代码块.
/*
synchronized (SellTicket03.class) {
System.out.println("m2");
}
*/
public synchronized static void m1() {
}
public static void m2() {
synchronized (SellTicket03.class) {
System.out.println("m2");
}
}
//说明
//1. public synchronized void sell() {} 就是一个同步方法
//2. 这时锁在 this对象
//3. 也可以在代码块上写 synchronize ,同步代码块, 互斥锁还是在this对象
public /*synchronized*/ void sell() { //同步方法, 在同一时刻， 只能有一个线程来执行sell方法
synchronized (/*this*/ object) {
if (ticketNum <= 0) {
System.out.println("售票结束...");
loop = false;
return;
}
//休眠50毫秒, 模拟
try {
Thread.sleep(50);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("窗口 " + Thread.currentThread().getName() + " 售出一张票"
+ " 剩余票数=" + (--ticketNum));//1 - 0 - -1 - -2
}
}
@Override
public void run() {
while (loop) {
sell();//sell方法是一共同步方法
}
}
}
//使用Thread方式
// new SellTicket01().start()
// new SellTicket01().start();
class SellTicket01 extends Thread {
private static int ticketNum = 100;//让多个线程共享 ticketNum
// public void m1() {
// synchronized (this) {
// System.out.println("hello");
// }
// }
@Override
public void run() {
while (true) {
if (ticketNum <= 0) {
System.out.println("售票结束...");
break;
}
//休眠50毫秒, 模拟
try {
Thread.sleep(50);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("窗口 " + Thread.currentThread().getName() + " 售出一张票"
+ " 剩余票数=" + (--ticketNum));
}
}
}
//实现接口方式
class SellTicket02 implements Runnable {
private int ticketNum = 100;//让多个线程共享 ticketNum
@Override
public void run() {
while (true) {
if (ticketNum <= 0) {
System.out.println("售票结束...");
break;
}
//休眠50毫秒, 模拟
try {
Thread.sleep(50);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("窗口 " + Thread.currentThread().getName() + " 售出一张票"
+ " 剩余票数=" + (--ticketNum));//1 - 0 - -1 - -2
}
}
}互斥锁
基本介绍
1.Java语言中，引入了对象互斥锁的概念，来保证共享数据操作的完整性。
2.每个对象都对应于一个可称为“互斥锁”的标记，这个标记用来保证在任一时刻，只能有一个线程访问该对象。
3.关键字synchronized 来与对象的互斥锁联系。当某个对象用synchronized修饰时表明该对象在任一时刻只能由一个线程访问
4同步的局限性:导致程序的执行效率要降低
5同步方法(非静态的)的锁可以是this,也可以是其他对象(要求是同一个对象)
6.同步方法(静态的)的锁为当前类本身
互斥锁案例
代码演示：
package com.syn;
/**
* 使用多线程，模拟三个窗口同时售票100张
*/
public class SellTicket {
public static void main(String[] args) {
SellTicket03 sellTicket03 = new SellTicket03();
new Thread(sellTicket03).start();//第1个线程-窗口
new Thread(sellTicket03).start();//第2个线程-窗口
new Thread(sellTicket03).start();//第3个线程-窗口
}
}
//实现接口方式, 使用synchronized实现线程同步
class SellTicket03 implements Runnable {
private int ticketNum = 100;//让多个线程共享 ticketNum
private boolean loop = true;//控制run方法变量
Object object = new Object();
//同步方法（静态的）的锁为当前类本身
//解读
//1. public synchronized static void m1() {} 锁是加在 SellTicket03.class
//2. 如果在静态方法中，实现一个同步代码块.
/*
synchronized (SellTicket03.class) {
System.out.println("m2");
}
*/
public synchronized static void m1() {
}
public static void m2() {
synchronized (SellTicket03.class) {
System.out.println("m2");
}
}
//说明
//1. public synchronized void sell() {} 就是一个同步方法
//2. 这时锁在 this对象
//3. 也可以在代码块上写 synchronize ,同步代码块, 互斥锁还是在this对象
public /*synchronized*/ void sell() { //同步方法, 在同一时刻， 只能有一个线程来执行sell方法
synchronized (/*this*/ object) {
if (ticketNum <= 0) {
System.out.println("售票结束...");
loop = false;
return;
}
//休眠50毫秒, 模拟
try {
Thread.sleep(50);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("窗口 " + Thread.currentThread().getName() + " 售出一张票"
+ " 剩余票数=" + (--ticketNum));//1 - 0 - -1 - -2
}
}
@Override
public void run() {
while (loop) {
sell();//sell方法是一共同步方法
}
}
}
互斥锁注意事项和使用细节
1.同步方法如果没有使用static修饰: 默认锁对象为this
2.如果方法使用static修饰，默认锁对象:当前类.class
3.实现的落地步骤 需要先分析上锁的代码
选择同步代码块或同步方法
要求多个线程的锁对象为同一个即可
线程的死锁
基本介绍
多个线程都占用了对方的锁资源，但不肯相让，导致了死锁，在编程是一定要避免死锁的发生
释放锁
下面操作会释放锁
1.当前线程的同步方法、同步代码块执行结束
2.当前线程在同步代码块、同步方法中遇到break、return
3.当前线程在同步代码块、同步方法中出现了未处理的Error或Exception，导致异常结束
4.当前线程在同步代码块、同步方法中执行了线程对象的wait0方法，当前线程暂停，并释放锁
下面操作不会释放锁
1.线程执行同步代码块或同步方法时，程序调用Thread.sleep()、Thread.yield()方法暂停当前线程的执行，不会释放锁
2.线程执行同步代码块时，其他线程调用了该线程的suspend()方法将该线程挂起该线程不会释放锁。
提示: 应尽量避免使用suspend()和resume()来控制线程，方法不再推荐使用
线程习题
第一题
代码演示：
要求：
(1)在main方法中启动两个线程
(2)第1个线程循环随机打印100以内的整数
(3)直到第2个线程从键盘读取了“Q”命令
package com.homework;
import java.util.Scanner;
/*
(1)在main方法中启动两个线程
(2)第1个线程循环随机打印100以内的整数
(3)直到第2个线程从键盘读取了“Q”命令
*/
public class Homework01 {
public static void main(String[] args) {
//第一种方法通过构造器传值
T1 t1 = new T1();
T2 t2 = new T2(t1);//一定要注意.
t1.start();
t2.start();
//第二种方法直接把loop变量设置成静态属性，通过类名直接调用即可
// T1 t1 = new T1();
// T2 t2 = new T2();
// t1.start();
// t2.start();
}
}
class T1 extends Thread {
public boolean loop = true;
@Override
public void run() {
while (loop) {
System.out.println((int) (Math.random() * 100 + 1));
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
}
public void setLoop(boolean loop) {
this.loop = loop;
}
}
class T2 extends Thread {
private T1 t;
Scanner scanner = new Scanner(System.in);
public T2(T1 t) {//构造器中，直接传入A类对象
this.t = t;
}
@Override
public void run() {
while (true) {
//接收到用户的输入
System.out.println("请输入字符");
char c = scanner.next().charAt(0);
if (c == 'q') {
//以通知的方式结束a线程
t.setLoop(false);
break;
}
}
}
}
//第二种方法直接把loop变量设置成静态属性，通过类名直接调用即可
//class T1 extends Thread {
// public static boolean loop = true;
//
// @Override
// public void run() {
// while (loop) {
// System.out.println((int) (Math.random() * 100 + 1));
// try {
// Thread.sleep(1000);
// } catch (InterruptedException e) {
// throw new RuntimeException(e);
// }
// }
// }
//
// public void setLoop(boolean loop) {
// this.loop = loop;
// }
//}
//
//class T2 extends Thread {
// Scanner scanner = new Scanner(System.in);
// @Override
// public void run() {
// while (true) {
// System.out.println("请输入字符");
// char c = scanner.next().charAt(0);
// if (c == 'q') {
// T1.loop = false;
// break;
// }
// }
// }
//}第二题
代码演示：
要求：
(1)有2个用户分别从同一个卡上取钱 (总额: 10000)
(2)每次都取1000,当余额不足时，就不能取款了
(3)不能出现超取现象 =》 线程同步问题
这题和我们上面的对售票习题相似，没有上面区别，也是使用 synchronized关键字即可
package com.homework;
/*
(1)有2个用户分别从同一个卡上取钱 (总额: 10000)
(2)每次都取1000,当余额不足时，就不能取款了
(3)不能出现超取现象 =》 线程同步问题
*/
public class Homework02 {
public static void main(String[] args) {
A a = new A();
new Thread(a).start();
new Thread(a).start();
}
}
//第一种方法使用同步代码块
//1.因为这里涉及到多个线程共享资源，所以我们使用实现Runnable方式
class A implements Runnable {
private double price = 10000;
@Override
public void run() {
while (true) {
//解读
//1. 这里使用 synchronized 实现了线程同步
//2. 当多个线程执行到这里时，就会去争夺 this对象锁
//3. 哪个线程争夺到(获取)this对象锁，就执行 synchronized 代码块, 执行完后，会释放this对象锁
//4. 争夺不到this对象锁，就blocked ，准备继续争夺
//5. this对象锁是非公平锁.
synchronized (this) {
if (price < 1000) {
System.out.println("余额不足，不能继续取款");
break;
}
System.out.println("用户" + Thread.currentThread().getName() + "取走了1000元，还剩下" + (price -= 1000));
}
try {
Thread.sleep(500);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
}
}
//第二种方法使用同步方法
//class A implements Runnable {
// private double price = 10000;
// private boolean loop = true;
// public synchronized void sell() {
// if (price < 1000) {
// System.out.println("余额不足，不能继续取款");
// loop = false;
// return;
// }
// System.out.println("用户" + Thread.currentThread().getName() + "取走了1000元，还剩下" + (price -= 1000));
// try {
// Thread.sleep(500);
// } catch (InterruptedException e) {
// throw new RuntimeException(e);
// }
// }
//
// @Override
// public void run() {
// while (loop) {
// sell();
// }
// }
//}
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
