多个线程访问同一个对象叫并发。
线程同步就是:排队
synchronized,当一个线程获得对象的排它锁,独占资源,其他线程必须等待,使用够释放锁即可。
代码块锁可以锁任何地方。
package Thread;
?
public class UnsafyBuyTickets {
public static void main(String[] args) {
BuyTicket buyTicket = new BuyTicket();
new Thread(buyTicket,"明").start();
new Thread(buyTicket,"刚").start();
new Thread(buyTicket,"老板").start();
?
}
}
class BuyTicket implements Runnable{
private int tickets = 10;
boolean falg = true;
@Override
public void run() {
//买票
while(falg){
buy();
}
?
}
private synchronized void buy(){
//判断是否有票
if (tickets<=0){
falg = false;
return;
}
//模拟代码延时
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+"拿到"+tickets--+"张票");
}
}
package Thread;
?
public class UnsafyBank {
public static void main(String[] args) {
Account account = new Account(2000000,"彩礼");
Drawing you = new Drawing(account,1000000,"自己");
Drawing wife = new Drawing(account,2000000,"妻子");
you.start();
wife.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;//取了多少钱
String name;
//现在手里有多少钱
int nowMoney;
public Drawing(Account account,int drawingMoney,String name){
super(name);
this.account = account;
this.drawingMoney = drawingMoney;
?
this.nowMoney = nowMoney;
}
?
@Override
public void run() {
//锁的对对象是变化的量,需要增删改操作的量。
synchronized (account){
if(account.money-drawingMoney<0){
System.out.println(Thread.currentThread().getName()+"钱不够,取不了");
return;
}
?
//模拟延时
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
account.money = account.money-drawingMoney;
nowMoney = nowMoney+drawingMoney;
System.out.println(account.name+"余额为"+account.money);
System.out.println(this.getName()+"手里的钱:"+nowMoney);
}
}
}
package Thread;
?
import java.util.ArrayList;
import java.util.List;
?
public class UnSafyList {
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());
}
?
}
?
原文:https://www.cnblogs.com/QIDream/p/14172632.html