synchronized锁机制同步

package _04;

public class _4_01Synchronized {
    public static void main(String[] args) {
        //锁机制 synchronized机制  排他锁
        //1.一个线程持有锁其他线程挂起
        //2.加锁、去锁会引起性能问题  导致比较多的上下文切换和调度延时
        //3.线程倒置   优先级高的等待优先级低的
        //锁对象： this、static(锁模子）  锁的位置： 方法和块（同步方法和同步块）

        //安全和性能 问题

        safeWeb sw = new safeWeb();
        Thread th1 = new Thread(sw,"w1");
        Thread th2 = new Thread(sw,"w2");
        Thread th3 = new Thread(sw,"w3");

        th1.start();
        th2.start();
        th3.start();


    }
}

class safeWeb implements  Runnable{

    private int ticketNum = 10;
    private boolean flag = true;

    @Override
    public void run() {
        while(flag){
            Test01();
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    //成员变量锁的是this  ,而这个this 是safeWeb  锁的是临界资源
    public synchronized void Test01(){
          if(ticketNum>0){
              ticketNum--;
              System.out.println(Thread.currentThread().getName()+":"+ticketNum);
          }else {
              flag =false;
              return;
          }
    }
    public void Test02(){
        synchronized (this){  //不能锁ticketNum 因为ticketNum变换则对象就会变化
            if(ticketNum>0){
              ticketNum--;
              System.out.println(Thread.currentThread().getName()+":"+ticketNum);
          }else {
              flag =false;
              return;
          }
        }
    }
    //尽可能锁合理的范围
    public void Test03(){
        //double checking
        if(ticketNum<=0){  //考虑的是没票的情况
            flag = false;
            return;
        }//缩小了锁定的范围
        synchronized (this){
            if(ticketNum<=0){  //而这个考虑最后一张票的情况
                flag = false;
                return;
            }
            try{
                Thread.sleep(200);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            ticketNum--;
            System.out.println(Thread.currentThread().getName()+":"+ticketNum);
        }
    }
}

package _04;

public class _4_02Synchrinized02 {
    public static void main(String[] args) {
//        Account ac = new Account();
//        safeDrawing sd1 = new safeDrawing(ac,900);
//        safeDrawing sd2 = new safeDrawing(ac,800);
//        new Thread(sd1,"sd1").start();
//        new Thread(sd2,"sd2").start();


        //例2  操作容器和对象的时候  同步块
//        synchronized (list){
//            list.add();//锁局部资源
//        }
    }
}

class Account{
    int AccountMoney=1000;
}

class safeDrawing implements  Runnable{
    Account account;
    int drawingmoney;
    int packetTotle =0;

    public safeDrawing(Account account,int drawingmoney){
        this.account =account;
        this.drawingmoney = drawingmoney;
    }

    @Override
    public void run() {
       Test01();
    }
    //锁定的目标不对、不应该锁this，而应该锁定account
    public synchronized void Test01(){
        //性能调优
        if(account.AccountMoney<0){
            return;
        }
        synchronized (account){
            if(account.AccountMoney - drawingmoney>0){
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                account.AccountMoney -= drawingmoney;
                packetTotle += drawingmoney;
                System.out.println(Thread.currentThread().getName()+":"+packetTotle+":"+account.AccountMoney);

            }else{
                return ;
            }
        }
    }
}

//同步容器的并发
package _04;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.CopyOnWriteArrayList;

public class _4_08SynContainer {
    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(10000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(list.size());
    }
}

//剧院并发处理的建议版本
package _04;

public class _4_08HappyCinema {
    public static void main(String[] args) {
        Cinema cinema = new Cinema(20,"happy sxt");
        new Thread(new Customer(cinema,2),"wei").start();
        new Thread(new Customer(cinema,2),"li").start();
    }
}

class Cinema{
    int available ;//可用位置
    String name   ;

    public Cinema(int available,String name){
        this.available = available;
        this.name = name;
    }

    public boolean bookTickets(int seats){
        System.out.println("可用座位数量："+this.available);
        if(seats>available){
            return false;
        }
        available -= seats;
        return true;
    }
}

class Customer implements Runnable{
    Cinema cinema;
    int seat;

    public Customer(Cinema cinema, int seat) {
        this.cinema = cinema;
        this.seat = seat;
    }

    @Override
    public void run() {
        synchronized (cinema){
            boolean flag = cinema.bookTickets(this.seat);
            if(flag){
                System.out.println("出票成功"+Thread.currentThread().getName());
            }
        }

    }
}