线程同步
并发：多个线程访问同一个对象，造成数据不安全
三个例子
package com.guanxing.syn;
public class UnsafeTicket {
public static void main(String[] args) {
BuyTicket station = new BuyTicket();
new Thread(station, "苦逼的我").start();
new Thread(station, "牛逼的你").start();
new Thread(station, "可恶的黄牛党").start();
}
}
class BuyTicket extends Thread {
//票
private int ticketNums = 10;
boolean flag = true;
@Override
public void run() {
while (flag) {
buy();
}
}
//买票的方法
public void buy() {
//判断是否有票
if (ticketNums <= 0) {
flag = false;
return;
}
//模拟延时
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
//买票
System.out.println(Thread.currentThread().getName()+"抢到了第"+ticketNums--+"张票");
}
}
package com.guanxing.syn;
//不安全的取钱
//两个人去银行取钱
public class UnsafeBank {
public static void main(String[] args) {
//账户
Account account = new Account(100, "结婚基金");
Drawing jay = new Drawing(account, 50, "jay");
Drawing kelly = new Drawing(account, 100, "kelly");
jay.start();
kelly.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(Thread.currentThread().getName()+"钱不够了！");
return;
}
//模拟延迟 放大问题的发生性
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
//卡内余额 = 余额 - 取的钱
account.money -= drawingMoney;
nowMoney += drawingMoney;
//你卡里的钱
System.out.println(account.name+"余额为："+account.money);
//你手里的钱
System.out.println(this.getName()+"手里的钱为："+nowMoney);
}
}
/*
结婚基金余额为：50
结婚基金余额为：-50
jay手里的钱为：50
kelly手里的钱为：100
*/
package com.guanxing.syn;
import java.util.ArrayList;
import java.util.List;
public class UnsafeList {
public static void main(String[] args) {
List<String> list = new ArrayList<String>();
for (int i = 0; i < 10000; i++) {
new Thread(()->{
list.add(Thread.currentThread().getName());
}).start();
}
try {
Thread.sleep(5000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(list.size()); //9617 没有sleep sleep5s 9999
}
}
死锁
某一个同步块同时拥有 “ 两个以上对象的锁 ” 时，就可能发生 “ 死锁 ” 现象。
两个或多个线程都在等待对方释放资源，都停止运行的情况
产生死锁的四个必要条件（想办法打破一个就可避免！）：
- 互斥条件：一个资源每次只能被一个进程使用
- 请求与保持条件：一个进程因请求资源而阻塞时，对已获得的资源保持不放
- 不剥夺条件：进程已获得的资源，在未使用完之前，不能抢行剥夺
- 循环等待条件：若干进程之间形成一种头尾相接的循环等待资源关系
package com.guanxing.syn;
//死锁：多个线程互相抱着对方需要的资源，形成僵持
public class DeadLock {
public static void main(String[] args) {
Makeup joey = new Makeup(0, "joey");
Makeup kane = new Makeup(1, "kane");
joey.start();
kane.start();
}
}
//口红
class Lipstick {
}
//镜子
class Mirror {
}
class Makeup extends Thread {
//口红和镜子（static保证都只有一个）
static Lipstick lipstick = new Lipstick();
static Mirror mirror = new Mirror();
//化妆者的选择和名字
int choice;
String girlName;
//构造器
public 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+"抢到口红了！");
}
}
}
Lock（锁）
显示定义同步锁对象来实现同步，手动开启和关闭锁
java.util.concurrent.locks.Lock 接口是控制多个线程对共享资源进行访问的工具
ReentrantLock 类实现了 Lock（re-entrant 可重入锁）
Lock只有代码块锁，syn有代码块锁和方法锁
package com.guanxing.syn;
import java.util.concurrent.locks.ReentrantLock;
//测试Lock锁
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 ticketNum = 1000;
//定义Lock锁
private final ReentrantLock lock = new ReentrantLock();
@Override
public void run() {
while (true) {
try {
lock.lock(); //加锁
if (ticketNum>0){
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+"-->"+ticketNum--);
}else {
break;
}
}finally {
//解锁
lock.unlock();
}
}
}
}