目录

synchronized 方法

这个就是一个关键字，在我们的方法上加这个关键字，那么这个方法就被同步了

这个是锁的 这个方法的类 本身


public class qp implements Runnable {
   
    private int ticket = 10;
    private boolean flag = true;

    @Override
    public void run() {
   
        while (flag){
   

            try {
   
                Thread.sleep(Long.parseLong("200"));
            } catch (InterruptedException e) {
   
                e.printStackTrace();
            }
            runn();

        }





    }

    private synchronized void  runn(){
   
        if(ticket <=0){
   
            return;
        }
        System.out.println(Thread.currentThread().getName() + "拿到了第" + ticket-- + "票");

    }

    public static void main(String[] args) {
   
        qp qp = new qp();
        Thread thread = new Thread(qp,"小红");
        Thread thread1 = new Thread(qp,"需");
        Thread thread2 = new Thread(qp,"uu");
        thread.start();
        thread1.start();
        thread2.start();
    }
}

以上的代码就是 ，将run方法里面的代码提取出来，另外写一个方法，在这个重新写 的方法上面加synchronized关键字，那么 现在线程就加锁了，在买票的时候，不会出现负数的情况

synchronized 块

这个同步监视器 的值就是对哪个对象进行增删改查 那么这个参数就是哪个值

这个就是需要锁 变化的量，这个变化的量 就是需要增删改查的对象

public class ArrayL {
   
    public static void main(String[] args)  {
   
        List<String> strings = new ArrayList<>();
        for(int i=0;i<10000;i++){
   
            new Thread(() -> {
   

代码块
                synchronized(strings) {
   
                    strings.add(Thread.currentThread().getName());
                }
            }).start();
        }
        try {
   
            Thread.sleep(Long.parseLong("3000"));
        } catch (InterruptedException e) {
   
            e.printStackTrace();
        }
        System.out.println(strings.size());
    }
}