线程同步:多个线程操作同一个资源
锁机制:synchronized
线程同步-锁机制存在的问题:
- 一个线程有锁会导致其他所i有需要此锁的线程挂起
- 再多个线程竞争下,加锁,释放锁会导致比较多的上下文切换和调度时延,引起性能问题
- 如果一个优先级高的线程等待一个优先级低的线程释放锁,会导致优先级倒置,引起性能问题
不安全状态
//不安全的买票
//线程不安全。票数有负数
//每个线程会在自己的工作内存交互,内存控制不当会造成数据不一致
public class UnsafeBuyTicket {
public static void main(String[] args) {
BuyTicket bt=new BuyTicket();
new Thread(bt,"庆安县的陌生人").start();
new Thread(bt,"西安的你").start();
new Thread(bt,"咸阳的我").start();
}
}
class BuyTicket implements Runnable{
//票
private int ticketNums=10;
boolean flag=true;//外部停止方式
@Override
public void run() {
// TODO Auto-generated method stub
//买票
while(flag) {
try {
buy();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
private void buy() throws InterruptedException {
//判断是否有票
if(ticketNums<=0) {
flag=false;
return;
}
//模拟延时
Thread.sleep(1000);
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 wife=new Drawing(account, 100, "你的妻子");
you.start();
wife.start();
}
}
class Account{
int money;//余额
String name;//卡名
public Account(int money, String name) {
// TODO Auto-generated constructor stub
}
}
//银行:模拟取款
class Drawing extends Thread{
Account account;//账户
int drawingMoney;//去多少钱
int nowMoney;//现在手里有多少钱
public Drawing(Account account,int drawingMoney,String name){
super(name);
this.account=account;
this.nowMoney=nowMoney;
this.drawingMoney=drawingMoney;
}
//取钱
public void run() {
// 判断账户有没有钱
if(account.money-drawingMoney<0) {
System.out.println(Thread.currentThread().getName()+"钱不够,取不了");
return;
}
//模拟延时
//sleep可以放大问题的发生性
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
//卡内余额=余额-取出的钱
account.money=account.money-drawingMoney;
//手里的钱=手里的钱+取出的钱
nowMoney=nowMoney+drawingMoney;
System.out.println(account.name+"余额为:"+account.money);
System.out.println(this.getName()+"手里的钱为:"+nowMoney);
}
}
//线程不安全的集合
public class UnsafeList {
public static void main(String[] args) {
List<String> list=new ArrayList<String>();
for(int i=0;i<100;i++) {
new Thread(()-> {
list.add(Thread.currentThread().getName());
}).start() ;
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println(list.size());
}
}
}
安全状态的完成:同步方法
我们可以通过private关键字来保证数据对象只能被方法访问,所以我们只需针对方法提供一套机制,这套机制就是synchronized关键字,他包括两种用法:
synchronized方法和synchronized快:
//同步方法:public sychronized void method(int args){
//}
synchronized方法控制对“对象”的访问,每个对象对应一把锁,每个synchronized方法都必须获取调用方法的对象的锁才能执行,否则线程会阻塞,方法一旦进行,就独占该锁,直到该方法返回才释放锁,后面被阻塞的线程才能获得这个锁,继续执行
//缺陷:若将一个大的方法申请为synchronized将会影响效率
//方法里面需要修改的资源才需要加锁,锁太多,浪费资源
//同步块:synchronized(Obj){}