线程同步的三种方案

以电影院售票为例

方案一：同步代码块

public class Cinerma {
int tickets = 50;//剩余票数
Object lock = new Object();//可以看做钥匙对象
//卖票函数
 public void  sellTicket(int num,int id) throws InterruptedException {//本函数一般跑在子线程中，所以在执行tickets = tickets -num;时会发生线程危险

if(tickets>=num){
            System.out.println(Thread.currentThread().getName()+id+":啊哈，有票，让我来跟售票员墨迹一会");//注意此处子线程的id
            Thread.sleep(200);
            System.out.println(Thread.currentThread().getName()+id+":墨迹完了，我要买票了");
            synchronized(lock){//正式买票，同步起来
                
                if(tickets>=num){
                    Thread.sleep(200);
                    tickets = tickets -num;
                    System.out.println(Thread.currentThread().getName()+id+":买了"+num+"张，剩余票数"+tickets);
                }else{
                    System.out.println(Thread.currentThread().getName()+id+":fuck=fuck=fuck=fuck=fuck，刚刚还有票的");
                }
            
            }
        }else{
            System.out.println("没票了咱走吧");
        }
       

方案二：使用加锁对象，ReentrantLock

ReentrantLock reentrantLock = new ReentrantLock();//放在成员里就好
//询问处的函数，一次只能一个线程来问，都排队
public void question(int id) throws InterruptedException{//运行在子线程中的方法
reentrantLock.lock();//此处开始同步
System.out.println(Thread.currentThread().getName()+id+":来买爆米花了");
Thread.sleep(3000);
System.out.println(Thread.currentThread().getName()+id+":买完了");
reentrantLock.unlock();//此处停止同步
}

调用方法：

Cinerma cinerma = new Cinerma();

Thread buyticketThread1 = new BuyTicketThread("情侣", 2, cinerma);//thread的名字，买票数，电影院对象
Thread buyticketThread2 = new BuyTicketThread("单身狗", 1, cinerma);
Thread askThread = new AskQuestionThread("爆米花",cinerma);

buyticketThread1.start();
buyticketThread2.start();
askThread.start();

class BuyTicketThread extends Thread{//买票线程

int num =0;
Cinerma cinerma;
public BuyTicketThread(String name,int num,Cinerma cinerma){
this.num = num;
this.cinerma = cinerma;
this.setName(name);//设置线程名
}

@Override
public void run() {
// TODO Auto-generated method stub
try {
for (int i = 0; i < 1000; i++) {//买1000张票
cinerma.sellTicket(num,i);

}
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}

public class AskQuestionThread extends Thread{//咨询线程
    
    Cinerma cinerma ;
    String name;
    public AskQuestionThread(String name,Cinerma cinerma){
        this.name = name;
        this.cinerma = cinerma;
    }
    
    @Override
    public void run() {
        // TODO Auto-generated method stub
        for (int i = 0; i < 3; i++) {
            try {
                cinerma.question(i);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
        
    }

}

方案3：notify()和wake()

建立一个场景，一位母亲有三个孩子，需要给他们做饭，一次只能做一个，每个孩子都要不停的吃饭，做饭和吃饭都需要时间，循环往复

首先建立一个厨房对象，这个对象是最主要的，里面有做饭和吃饭两个方法，重点是，这两个方法都要用synchronized修饰

public class Kitchen {
int food = 0;//剩余的饭
//做饭函数
 public synchronized void cook() throws InterruptedException{//注意这个函数被synchronized给修饰了
if(food>0){//如果当前还有饭

wait();//妈妈线程等待,等待孩子线程notify她，函数会停留在这一句不动，直到有notify
//如果被notify了，则执行下面的
 food = food +1;//做饭
System.out.println("做完饭后一共剩余"+food);
System.out.println(Thread.currentThread().getName()+"：饭做好了");
notifyAll();//呼叫孩子线程

}else{//如果当前没剩饭了
food = food +1;
System.out.println(food);
System.out.println(Thread.currentThread().getName()+"：饭做好了");
notifyAll();//通知孩子线程

}
<pre name="code" class="java">                System.out.println("通知完孩子后剩余"+food);

}//吃饭函数public synchronized void eat() throws InterruptedException {//在子线程中调用if(food == 0){wait();//孩子线程等待，等妈妈线程唤醒他，此时函数会停留在这一句

//如果这个时候被notify了

food -=1;//吃饭 System.out.println(Thread.currentThread().getName()+"抢到了");notifyAll();//通知她妈没饭了System.out.println(food);}else{food -=1;//吃饭System.out.println(food);System.out.println(Thread.currentThread().getName()+"抢到了");notifyAll();//通知她妈System.out.println(food);}}}

使用四个线程，包含一个妈妈线程三个孩子线程，不停的调用kitchen里的方法，如下

Kitchen kitchen = new Kitchen();
Thread motherThread = new Mother(kitchen);
Thread chilThread1 = new Childrens("大娃", kitchen);
Thread chilThread2 = new Childrens("二娃", kitchen);
Thread chilThread3 = new Childrens("三娃", kitchen);

motherThread.start();
chilThread1.start();
chilThread2.start();
chilThread3.start();

//下面是三个线程的定义
public class Childrens extends Thread{
    Kitchen kitchen;
    public Childrens(String name,Kitchen kitchen){
        this.kitchen = kitchen;
        this.setName(name);
        
    }
    @Override
    public void run() {
        // TODO Auto-generated method stub
        for (int i = 0; i < 3; i++) {
            try {
                kitchen.eat();
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
        System.out.println(Thread.currentThread().getName()+"吃饱了");
        
        
    }
}
public class Mother extends Thread{
    Kitchen kitchen;
    
    public Mother(Kitchen kitchen){
        this.kitchen = kitchen;
    }
    @Override
    public void run() {
        // TODO Auto-generated method stub
        while (true) {
            
        
        try {
            kitchen.cook();
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        }

    }

}