线程同步
由于同一进程的多个线程共享同一块存储空间，在带来方便的同时，也带来了访问冲突问题，为了保证数据在方法中被访问时的正确性，在访问时加入锁机制 synchronized，当一个线程获得对象的排它锁，独占资源，其他线程必须等待，使用释放锁即可，但同时也会带来如下问题：
- 一个线程持有锁会导致其他所有需要此锁的线程挂起
- 在多线程竞争下，加锁、释放锁会导致频繁的 上下文切换 和 调度延时，引起性能问题
- 如果一个优先级高的线程等待一个优先级低的线程释放锁，会导致优先级倒置，引起性能问题
同步方法
synchronized关键字
包括synchronized方法和synchronized块两种方法
同步方法 public synchronized void method(int args){}
- synchronized方法控制对象的访问，每个对象对应一把锁，每个synchronized方法都必须获得调用该方法的对象的锁才能执行，否则线程会阻塞，方法一旦执行，就独占该锁，直到该方法返回才释放锁，后面被阻塞的线程才能获得这个锁，继续执行
同步块
- 同步块 synchronized（Obj）{}
（Obj）{}同步监视器
- Obj可以是任何对象，推荐使用共享资源作为同步监视器
- 同步方法中无须指定同步监视器，因为同步方法的同步监视器就是这个对象本身，或者是class
执行过程
- 第一个线程访问，锁定同步监视器，执行其中代码
- 第二个线程访问，发现同步监视器被锁定，无法访问
- 第一个线程访问完毕，释放同步监视器锁
- 第二个线程访问，发现同步监视器没有锁，锁定并进行访问
买票问题
package com.thread.syn;
/**
* @Author suaxi
* @Date 2020/11/26 14:40
* 不安全的买票，结果中出现负的票数
*/
public class UnsafeBuyTicket {
public static void main(String[] args) {
BuyTicket buyTicket = new BuyTicket();
new Thread(buyTicket,"孙笑川").start();
new Thread(buyTicket,"药水哥").start();
new Thread(buyTicket,"Giao哥").start();
}
}
class BuyTicket implements Runnable{
//票
private int ticketNums = 10;
//外部停止标志
boolean flag = true;
@Override
public void run() {
while (flag){
try {
buy();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
//synchronized同步方法
private synchronized void buy() throws InterruptedException {
//判断是否有票
if (ticketNums<=0){
flag = false;
return;
}
//模拟延时
Thread.sleep(100);
//买票
System.out.println(Thread.currentThread().getName()+"买到了票"+ticketNums--);
}
}模拟取款
package com.thread.syn;
/**
* @Author suaxi
* @Date 2020/11/26 15:03
*/
public class UnsafeBank {
public static void main(String[] args) {
//账户
Account account = new Account(100, "存折");
Drawing sun = new Drawing(account, 50, "孙笑川");
Drawing yao = new Drawing(account, 100, "药水哥");
sun.start();
yao.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 cash; //现金
public Drawing(Account account,int drawingMoney,String name){
super(name);
this.account = account;
this.drawingMoney = drawingMoney;
}
//取钱
//synchronized 默认锁的是this.
@Override
public void run() {
//synchronized锁的对象就是变化的量，即需要增删改的对象
synchronized (account){
//判断余额
if (account.money-drawingMoney<0){
System.out.println(Thread.currentThread().getName()+"账户余额不足");
return;
}
//sleep可以放大问题的发生性
try {
Thread.sleep(3000);
} catch (InterruptedException e) {
e.printStackTrace();
}
//余额 = 卡内余额 - 取款额度
account.money = account.money - drawingMoney;
//现金
cash = cash + drawingMoney;
System.out.println(account.name+"账户余额："+account.money);
//继承Thread类，所以此处的this.getName() = Thread.currentThread().getName()
System.out.println(this.getName()+"现金："+cash);
}
}
}线程不安全的集合
package com.thread.syn;
import java.util.ArrayList;
import java.util.List;
/**
* @Author suaxi
* @Date 2020/11/26 14:59
* 线程不安全的集合
*/
public class UnsafeList {
public static void main(String[] args) {
List<String> list = new ArrayList<String>();
for (int i = 0; i < 10000; i++) {
new Thread(() ->{
synchronized (list){
list.add(Thread.currentThread().getName());
}
}).start();
}
try {
Thread.sleep(3000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(list.size());
}
}
补充：JUC安全类型的集合CopyOnWriteArrayList
package com.thread.syn;
import java.util.concurrent.CopyOnWriteArrayList;
/**
* @Author suaxi
* @Date 2020/11/26 15:48
* 测试JUC安全类型的集合
*/
public class TestJUC {
public static void main(String[] args) {
CopyOnWriteArrayList<String> list = new CopyOnWriteArrayList<String>();
for (int i = 0; i < 1000; i++) {
new Thread(() ->{
list.add(Thread.currentThread().getName());
}).start();
}
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(list.size());
}
}
评论 (0)