- 1 线程同步
- 2 线程不安全场景
- 3 同步方法
- 4 死锁
- 5 Lock锁
- 6 synchronized与Lock锁对比
线程同步-多个线程操作同一个资源
多线程访问同一个对象，还想修改这个对象，这就需要线程同步，线程同步其实就是一种等待机制，多个需要同时访问次对象的线程进入这个对象的等待池形成队列，等待前面线程使用完毕，下一个线程再使用。
线程同步条件 队列+锁
由于同一进程的多个线程共享同一块存储空间，在带来方便的同时，也带来了访问冲突问题，为了保证数据在方法中被访问时的正确性，在访问时加入锁机制，当一个线程获得对象的排他锁，独占资源，其他线程必须等待，使用后释放锁即可：
- 一个线程持有锁会导致其他所有需要此锁的线程挂起
- 在多线程竞争下，加锁，释放锁会导致比较多的上下文切换和调度延时，引起性能问题
- 如果一个优先级高的线程等待一个优先级低的线程释放锁，会导致优先级倒置，引起性能问题。
抢票场景
// 不安全的买票
// 出现复数 线程不安全
public class UnsafeBuyTicket {
public static void main(String[] args) {
BuyTicket station = new BuyTicket();
new Thread(station, "苦逼的我").start();
new Thread(station, "牛逼的我").start();
new Thread(station, "讨厌的黄牛").start();
}
}
class BuyTicket implements Runnable {
// 票
private int ticketNums = 10;
private boolean flag = true;
@Override
public void run() {
// 买票
while (flag) {
buy();
}
}
private void buy() {
// 判断是否有票
if (ticketNums <= 0) {
flag = false;
return;
}
// 模拟延时
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
// 买票
System.out.println(Thread.currentThread().getName() + "拿到" + ticketNums--);
}
}
原因分析
每个线程都会维护自己的工作内存，当票池里面只有一张票的时候，两个抢票者都把”1“拿到自己的内存中，然后以为可以买票，所以就出现了负数
取钱场景
public class UnsafeBank {
public static void main(String[] args) {
Account account = new Account(100, "基金");
Drawing you = new Drawing(account, 50, "自己");
Drawing girlFriend = new Drawing(account, 100, "老婆");
you.start();
girlFriend.start();
}
}
// 账户
class Account {
int money;
String name;
public Account(int money, String name) {
this.money = money;
this.name = name;
}
}
// 银行:模拟取款
class Drawing extends Thread {
Account account; //账户
int drawingMoney; // 取多少钱
int nowMoney; // 还有多少钱
public Drawing(Account account, int drawingMoney, String name) {
super(name);
this.account = account;
this.drawingMoney = drawingMoney;
}
@Override
public void run() {
// 判断有没有钱
if (account.money-drawingMoney <= 0) {
System.out.println(account.name + "没有钱可以取");
return;
}
// 卡内余额 = 余额-你取的钱
account.money = account.money - drawingMoney;
nowMoney = nowMoney + drawingMoney;
// 你手里的钱
System.out.println(account.name + "余额为" + account.money);
System.out.println(this.getName() + "取走了" + nowMoney);
}
}
`
3 同步方法synchronized 关键字控制”对象“的访问
将一个方法修饰成synchronized 会影响效率
方法里面需要修改的内容才需要锁
修饰方法
public class UnsafeBuyTicket {
public static void main(String[] args) {
BuyTicket station = new BuyTicket();
new Thread(station, "苦逼的我").start();
new Thread(station, "牛逼的我").start();
new Thread(station, "讨厌的黄牛").start();
}
}
class BuyTicket implements Runnable {
// 票
private int ticketNums = 10;
private boolean flag = true;
@Override
public void run() {
// 买票
while (flag) {
buy();
}
}
// synchronized 同步方法
private synchronized void buy() {
// 判断是否有票
if (ticketNums <= 0) {
flag = false;
return;
}
// 模拟延时
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
// 买票
System.out.println(Thread.currentThread().getName() + "拿到" + ticketNums--);
}
}
修饰对象
public class UnsafeBank {
public static void main(String[] args) {
Account account = new Account(100, "基金");
Drawing you = new Drawing(account, 50, "自己");
Drawing girlFriend = new Drawing(account, 100, "老婆");
you.start();
girlFriend.start();
}
}
// 账户
class Account {
int money;
String name;
public Account(int money, String name) {
this.money = money;
this.name = name;
}
}
// 银行:模拟取款
class Drawing extends Thread {
Account account; //账户
int drawingMoney; // 取多少钱
int nowMoney; // 还有多少钱
public Drawing(Account account, int drawingMoney, String name) {
super(name);
this.account = account;
this.drawingMoney = drawingMoney;
}
@Override
public void run() {
synchronized (account) {
// 判断有没有钱
if (account.money - drawingMoney <= 0) {
System.out.println(account.name + "没有钱可以取");
return;
}
// 卡内余额 = 余额-你取的钱
account.money = account.money - drawingMoney;
nowMoney = nowMoney + drawingMoney;
// 你手里的钱
System.out.println(account.name + "余额为" + account.money);
System.out.println(this.getName() + "取走了" + nowMoney);
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
锁的对象就是变化的量-增、删、改
JUC java.utils.concurrent java并发编程包，安全类型集合
import java.util.concurrent.CopyOnWriteArrayList;
public class TestJUC {
public static void main(String[] args) throws InterruptedException {
CopyOnWriteArrayList list = new CopyOnWriteArrayList();
for (int i = 0; i < 10000; i++) {
new Thread(()->{
list.add(Thread.currentThread().getName());
}).start();
}
Thread.sleep(3000);
System.out.println(list.size());
}
}
4 死锁
多个线程各自占有一些共享资源，并且相互等待其他线程占有的资源才能运行，而导致两个或者多个线程都在等待对方释放资源，都停止执行的情形。某一个同步块拥有”两个以上对象的锁“时，就可能会发生”死锁“的问题
// 死锁：多个线程互相持有对方需要的资源，形成僵持
public class DeadLock {
public static void main(String[] args) {
Makeup g1 = new Makeup(0, "灰姑娘");
Makeup g2 = new Makeup(1, "白雪公主");
g1.start();
g2.start();
}
}
// 口红类
class Lipstick {
}
// 镜子
class Mirror {
}
// 化妆
class Makeup extends Thread {
// 需要的资源只有一份，用static保证只有一份
static Lipstick lipstick = new Lipstick();
static Mirror mirror = new Mirror();
int choice;
String girlName;
Makeup(int choice, String girlName) {
this.choice = choice;
this.girlName = girlName;
}
@Override
public void run() {
try {
makeup();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
// 化妆，互相持有对方的锁
private void makeup() throws InterruptedException {
if (choice == 0) {
synchronized (lipstick) {// 获得口红的锁
System.out.println(this.girlName + "获得口红的锁");
Thread.sleep(1000);
synchronized (mirror) { // 一秒钟后获得镜子
System.out.println(this.girlName + "获得镜子的锁");
}
}
} else {
synchronized (mirror) {//
System.out.println(this.girlName + "获得镜子的锁");
Thread.sleep(2000);
synchronized (lipstick) { //
System.out.println(this.girlName + "获得口红的锁");
}
}
}
}
}
解决方法：
private void makeup() throws InterruptedException {
if (choice == 0) {
synchronized (lipstick) {// 获得口红的锁
System.out.println(this.girlName + "获得口红的锁");
Thread.sleep(1000);
}
synchronized (mirror) { // 一秒钟后获得镜子
System.out.println(this.girlName + "获得镜子的锁");
}
} else {
synchronized (mirror) {//
System.out.println(this.girlName + "获得镜子的锁");
Thread.sleep(2000);
}
synchronized (lipstick) { //
System.out.println(this.girlName + "获得口红的锁");
}
}
}
生成死锁的四个必要条件
- 互斥条件：一个资源每次只能被一个进程使用
- 请求与保护条件：一个进程因请求资源而阻塞时，对方获得的资源保持不放
- 不剥夺条件：进程以获得的资源，在未使用完之前，不能强行剥夺
- 循环等待条件：若干进程之间形成一种头尾相接的循环等待资源关系
上面列出了死锁的四个必要条件，只要想办法破其中的一个或者多个条件就可以避免死锁发生
5 Lock锁JUC包内的锁
Lock锁使用方式：
class A{
private final ReentrantLock lock = new ReentrantLock();
public void m(){
try{
lock.lock();
}finally{
lock.unlock();
}
}
}
import java.util.concurrent.locks.ReentrantLock;
public class TestLock {
public static void main(String[] args) {
MyLock myLock = new MyLock();
new Thread(myLock).start();
new Thread(myLock).start();
new Thread(myLock).start();
}
}
class MyLock implements Runnable {
int ticketNums = 10;
// 定义lock锁
private final ReentrantLock lock = new ReentrantLock();
@Override
public void run() {
while (true) {
try{
lock.lock();
if (ticketNums>0){
System.out.println(ticketNums--);
}
else{
break;
}
} catch (Exception e){
e.printStackTrace();
} finally {
lock.unlock();
}
}
}
}
6 synchronized与Lock锁对比
- Lock时显示锁（手动开启和关闭锁，别忘记关闭锁）synchronized是隐式锁，出了作用域自动释放
- Lock只有代码块锁，synchronized有代码块锁和方法锁
- 使用Lock锁，JVM将花费较少的时间来调度线程，性能更好。并且具有更好的扩展性
- 优先使用顺序：
- Lock > 同步代码块(进入了方法体，分配了相应资源) > 同步方法(在方法体之外)
