synchronized锁

它是多线程并发编程，重量级锁。JDK1.6对synchronized进行了优化。
JDK1.6为了减少获得锁和释放锁带来的性能消耗引入的偏向锁和轻量级锁。

synchronized有三种方式来加锁：

  1. 修饰实例方法，作用于当前实例加锁，进入同步代码前要获得当前实例的锁
  2. 静态方法，作用于当前类对象加锁，进入同步代码前要获得的当前类对象的锁
  3. 代码块，指定加锁对象，对给定对象加锁，进入同步代码块之前要获得给定对象的锁

synchronized都可以给哪些上锁

  1. 实例方法：调用该方法的实例
  2. 静态方法：类对象
  3. this：调用该方法的实例对象
  4. 类对象：类对象

基础运用

操作共享数据的代码
共享数据：多个线程共同操作的变量，都可以充当锁

public class Ch01 {

    public static void main(String[] args) {
        // 同步代码块
        // 创建一个对象
        // 类对象
        // 当前实例this
        // 同步监视器
        synchronized (Ch01.class) {
            int a = 1;
        }
    }
}

关于同步方法：

  1. 同步方法依然会涉及到同步锁对象，不需要我们写出来
  2. 非静态的同步方法，同步锁就是this；静态的同步方法，同步监视器就是类本身

同步代码块：

  1. 选好同步监视器（锁）推荐使用类对象，第三方对象，this
  2. 在实现接口创建的线程类中，同步代码块不可以用this来充当同步锁

同步的方式，解决线程安全的问题：

操作同步代码时，只有一个线程能够参与，其他线程等待
相当于一个单线程的过程，效率低

synchronized只针对于当前JVM可以解决线程安全问题。
synchronized不可以跨JVM解决问题！！！

加锁卖票

class Windows3 extends Thread {

    private static int tickets = 100;

    private String name;

    public Windows3(String name) {
        this.name = name;
    }
    @Override
    public void run() {
        sell();
    }

    private synchronized void sell() {
        while (true) {
            if (tickets >0 ) {
                try {
                    Thread.sleep(20);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                System.out.println(name+"卖票，剩余："+tickets-- +"张！");
            } else {
                break;
            }
        }
    }
}
// 卖票
public class Ch03 {

    public static void main(String[] args) {
        Windows3 w1 = new Windows3("one");
        Windows3 w2 = new Windows3("two");

        w1.start();
        w2.start();
    }
}

死锁

死锁的情形：多个线程同时被阻塞，他们中的一个或者全部
都在等待某个资源的释放，由于线程无限期的阻塞，程序就不可能正常终止

Java死锁产生有四个必要条件

  1. 互斥使用，当资源被一个线程使用（占用），别的线程不能使用。
  2. 不可抢占，资源请求者不能强制从占有者中抢夺资源，资源只能从占有者手动释放
  3. 请求和保持
  4. 循环等待，存在一个等待队列，P1占有P2的资源，P2占有了P3的资源，P3占有P1的资源，形成了一个等待环路

线程重入

任意线程在拿到锁之后，再次获取该锁不会被该锁所阻碍
线程不会被自己锁死的。这就叫线程的重入，synchronized可重入锁。

JDK1.6以后锁升级：

  1. 无锁：不加锁
  2. 偏向锁：不锁锁，只有一个线程争夺时，偏向某一个线程，这个线程不加锁
  3. 轻量级锁：少量线程来了之后，向尝试自旋，不挂起线程。
  4. 重量级锁：排队挂起（暂停）线程。（synchronized）
挂起线程和恢复线程需要转入内核态中完成这些操作，给系统的并发性带来很大的压力。
在许多应用上共享数据的锁定状态，只会持续很短的时间，为了这段时间去挂起和恢复并不值得
我们可以让后面的线程等待一下，不要放弃处理器的执行时间。锁为了让线程等待，我们只需要让线程执行一个循环，自旋。【自旋锁】
public class Ch05 {

    private static final Object M1 = new Object();
    private static final Object M2 = new Object();

    public static void main(String[] args) {
        new Thread(() -> {
            synchronized (M1) {
                synchronized (M2) {
                    synchronized (M1) {
                        synchronized (M2){
                            System.out.println("hello lock");
                        }
                    }
                }
            }
        }).start();
    }
}

Object类对多线程的支持

wait():当前线程进入等待状态
notify()：唤醒正在等待的下一个线程
notifyAll()：唤醒正在等待的所有线程

线程间的通信

比如两条线程，共同运行。
线程A如果先走，线程B就要等待。等待线程A走完，唤醒线程B，线程B再走

方法总结

  1. Thread的两个静态方法：
    sleep释放CPU资源，但是不会释放锁
    yield方法释放CPU执行权，保留了CPU的执行资格，不常用。
  2. join方法，yield出让了执行权，join就加入进来。
  3. wait：释放CPU资源，释放锁
    notify：唤醒等待中的线程
    notifyAll：唤醒等待中的所有线程

sleep和wait的区别

  1. 使用 sleep 方法可以让线程休眠，而使用 wait 方法则必须放在 synchronized 块里面。
  2. wait还需要额外的方法notify/ notifyAll 进行唤醒，它们同样需要放在 synchronized 块里面，且获取对象的锁。当然也可以使用带时间的 wait(long millis) 方法，时间一到，无需其他线程唤醒，也会重新竞争获取对象的锁继续执行。
  3. sleep方法短暂休眠之后会主动退出阻塞，而没有指定时间的wait方法则需要被其他线程中断后才能退出阻塞。sleep()和yield()是Thread类的方法。
  4. wait() 是Object中定义的native方法。sleep()方法自带sleep时间，时间过后，Thread会自动被唤醒。 或者可以通过调用interrupt()方法来中断。

案例：生产者与消费者模型

两条线程，一条线程生产产品，另一条线程消费产品

class Factory implements Runnable {

    @Override
    public void run() {

        synchronized (Ch02.OBJ){
            while(true){
                // 生产电脑
                System.out.println("工厂生产电脑，已经生产了：" + Ch02.count ++ + "台！");
                if(Ch02.count >= 100) {
                    notifyAll();
                    try {
                        wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    }
}

class Consumer implements Runnable {

    @Override
    public void run() {
        synchronized (Ch02.OBJ){
            while(true){
                if(Ch02.count >= 0){
                    // 消费电脑
                    System.out.println("消费者消费了1台电脑，剩余：" + Ch02.count-- + "台！");
                }
                if(Ch02.count <= 0){
                    try {
                        wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    notifyAll();
                }
            }

        }
    }
}

public class Ch02 {

    public static final Object OBJ = new Object();

    public static int count = 0;

    public static void main(String[] args) {
        Thread t1 = new Thread(new Factory());
        Thread t2 = new Thread(new Consumer());

        t1.start();
        t2.start();
    }
}

线程的退出

使用退出标志，线程正常退出，run方法结束后线程终止，不要使用stop方法。

class MyThread extends Thread {

    volatile boolean flag = true;

    @Override
    public void run() {
        while(flag) {
            try {
                System.out.println("线程一直在运行...");
                int i = 10 / 0;
            } catch (Exception e) {
                this.stopThread();
            }
        }
    }
    public void stopThread() {
        System.out.println("线程停止运行...");
        this.flag = false;
    }
}

public class Ch03 {

    public static void main(String[] args) {
        MyThread myThread = new MyThread();
        myThread.start();
    }
}

interrupt方法

中断线程，调用interrupt方法会抛出InterruptedException异常，捕获后再做停止线程的逻辑即可。
如果线程while(true)运行的状态，interrupt方法无法中断线程。

class MyThread02 extends Thread {

    private boolean flag = true;

    @Override
    public void run() {
        while(flag) {
            synchronized (this){
                try {
                    sleep(10000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                    this.stopThread();
                }
            }
        }
    }
    public void stopThread() {
        System.out.println("线程停止运行...");
        this.flag = false;
    }
}
public class Ch04 {
    public static void main(String[] args) {
        MyThread02 myThread02 = new MyThread02();
        myThread02.start();

        System.out.println("线程开始...");

        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        // 中断线程的执行
        myThread02.interrupt();
    }
}

线程的常用方法

Thread类中的方法

  1. start：启动当前线程；执行run方法
  2. run：Thread中需要重写的方法
  3. currentThread：静态方法，获取当前正在执行的线程
  4. getId()：返回此线程的唯一标识
  5. setName(String)：设置当前线程的name
  6. getName()：获取当前线程的name
  7. getPriority()：获取当前线程的优先级
  8. setPriority(int)：设置当前线程的优先级
  9. getState()：获取当前线程的声明周期
  10. interrupt()：中断线程的执行
  11. interrupted()：查看当前线程是否中断
class MyThread03 extends Thread {

    @Override
    public void run() {
        System.out.println(getId());
        setName("线程一");
        System.out.println(getName());
    }
}

public class Ch05 {

    public static void main(String[] args) {
        MyThread03 myThread03 = new MyThread03();
        myThread03.setDaemon(true);
        myThread03.start();
        
        System.out.println(myThread03.isDaemon());
    }
}

多线程的单例

class Singleton {
    private static Singleton instant;

    private Singleton(){}

    public static Singleton getInstance() {
        if(instant == null) {
            synchronized (Singleton.class) {
                if(instant == null){
                    instant = new Singleton();
                }
            }
        }
        return instant;
    }
}

public class Ch06 {
    public static void main(String[] args) {
        System.out.println(Singleton.getInstance() == Singleton.getInstance());
    }
}

经典例题 包子

全部代码 

class BunProduct extends Thread {

    @Override
    public void run() {
        while (true) {
            synchronized (Bun.obj) {
                if (Bun.state ==0 ) {
                    try {
                        Thread.sleep(200);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("包子铺开始作包子");
                    Bun.state ++;
                }
            }
        }
    }
}

class BunMeat extends Thread {

    @Override
    public void run() {
        while (true) {
            synchronized (Bun.obj) {
                if (Bun.state == 1 ) {
                    try {
                        Thread.sleep(200);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("包子做好了薄皮牛肉");
                    Bun.state =2;
                }
            }
        }
    }
}

class BunEat extends Thread {

    @Override
    public void run() {
        while (true) {
            synchronized (Bun.obj) {
                if (Bun.state == 2 ) {
                    try {
                        Thread.sleep(200);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("吃货正在吃包子薄皮牛肉");
                    System.out.println("====================");
                    Bun.state =0;
                }
            }
        }
    }
}


public class Bun {

    public static volatile int state = 0;

    public static final Object obj = new Object();

    public static void main(String[] args) {
        Thread t1 = new Thread(new BunProduct());
        Thread t2 = new Thread(new BunMeat());
        Thread t3 = new Thread(new BunEat());

        t1.start();
        t2.start();
        t3.start();
    }
}

LockSupport工具类

线程阻塞的工具类，所有的方法都是静态方法，可以让线程在任意位置阻塞，阻塞之后也有唤醒的方法。
park：停车。如果我们把Thread看成一辆车的话，park就是让车停下
unpark：就是让车启动然后跑起来

这里的park和unpark其实实现了wait和notify的功能。
区别：

  1. park不需要获取某个对象的锁（不释放锁）
  2. 因为中断park不会抛出InterruptedException异常，需要在park之后自行判断中断状态，然后做额外的处理。

总结：

  1. park和unpark可以实现wait和notify的功能，但是并不和wait和notify交叉使用。
  2. park和unpark不会出现死锁。
  3. blocker的作用看到阻塞对象的信息

简单运用 

public class Ch01 {

    public static final Object OBJ = new Object();

    public void show() {
        try {
            super.wait();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) throws InterruptedException {
        Runnable runnable = () -> {
            synchronized (OBJ) {
                System.out.println("线程【" + Thread.currentThread().getName() + "】正在执行...");
                // 阻塞
                LockSupport.park("我被阻塞了...");
                if(Thread.currentThread().isInterrupted()){
                    System.out.println("被中断了...");
                }
                System.out.println("继续执行...");
            }
        };
        Thread t1 = new Thread(runnable,"线程一");
        Thread t2 = new Thread(runnable,"线程二");

        t1.start();
        Thread.sleep(1000);
        System.out.println(LockSupport.getBlocker(t1));
        t2.start();
        Thread.sleep(3000);
        // 线程中断
        t1.interrupt();
        // 把t2唤醒
        LockSupport.unpark(t2);
        t1.join();
        t2.join();
    }
}

ReentrantLock实现类

ReentrantLock，可重入锁。实现了Lock接口

synchronized和Lock的区别：

  1. Lock是一个接口，synchronized是一个关键字，是由底层（C）语言实现的。
  2. synchronized发生异常时，会自动释放线程占用的锁不会发生死锁。Lock发生异常，若没有主动释放，极有可能占用资源不放手，需要在finally中手动释放锁。
  3. Lock可以让等待锁的线程响应中断，使用synchronized只会让等待的线程一直等待下去，不能响应中断
  4. Lock可以提高多个线程进行读操作的效率。

用lock来卖票

class Ticket implements Runnable {
    private static final ReentrantLock lock = new ReentrantLock();
    private static Integer count = 100;
    String name;

    public Ticket(String name) {
        this.name = name;
    }

    @Override
    public void run() {
        while(Ticket.count > 0){
            lock.lock();
            try {
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                if(count > 0){
                    System.out.println(name + "正在卖票，剩余：" + count + "张！");
                    count--;
                    // count = count - 1;
                }
            }finally {
                lock.unlock();
            }
        }
    }
}

public class Ch03 {
    public static void main(String[] args) {
        Ticket t1 = new Ticket("窗口一");
        Ticket t2 = new Ticket("窗口二");
        Ticket t3 = new Ticket("窗口三");

        new Thread(t1).start();
        new Thread(t2).start();
        new Thread(t3).start();
    }
}

Lock以下功能是synchronized不具备的！

ReentrantReadWriteLock对于一个应用而言，一般情况下读操作远远多于写的操作，如果仅仅是读的操作没有写的操作，数据又是线程安全，读写锁给我们提供了一种锁，读的时候可以很多线程一起读，但是不能有线程写，写是独占的，当有线程在执行写的操作，其他线程既不能读，也不能写。

public class Ch04 {

    private static ReentrantReadWriteLock lock = new ReentrantReadWriteLock();

    private static int count = 1;

    public static void main(String[] args) {
        Runnable read = () -> {
            // 创建了一个读锁
            ReentrantReadWriteLock.ReadLock readLock = lock.readLock();
            readLock.lock();
            try {
                Thread.sleep(2000);
                System.out.println("我在读数据：" + count);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }finally {
                readLock.unlock();
            }
        };
        Runnable write = () -> {
            // 创建了一个写锁
            ReentrantReadWriteLock.WriteLock writeLock = lock.writeLock();
            writeLock.lock();
            try {
                Thread.sleep(2000);
                System.out.println("我在写数据：" + count++);
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                writeLock.unlock();
            }
        };
        for (int i = 0; i < 100; i++) {
            Random random = new Random();
            int flag = random.nextInt(100);
            System.out.println("生成的随机整数：" + flag);
            if(flag > 20){
                new Thread(read).start();
            }else {
                new Thread(write).start();
            }
        }
    }
}

lock锁的原理cas和aqs

synchronized是由C语言实现的，只能作为关键字来使用，java提供了一些并发的编程的包，底层的实现原理cas和aqs

并发编程三大特性：
1.原子性：原子操作可以是一个步骤，也可以是多个步骤，但是顺序不能乱，也不可以被切割只执行其中的一部分，将整个操作视为一个整体。原子性不仅仅是多行代码，也可能是多条指令。
2.可见性
3.有序性
synchronized lock：可以保证原子性、可见性、有序性。
CAS：compare and swap，比较并交换。JDK11改成了compare and set。思路：就是给一个元素赋值的时候，先看看内存里的那个值到底变没变。
AQS：抽象队列同步器，用来解决线程同步执行的问题。它是一个双向链表

JUC并发编程包

原子类Atomic

基本类型
AtomicInteger：整型原子类
AtomicLong：长整型原子类
AtomicBoolean：布尔型原子类

数组类型
AtomicLongArray：长整型数组原子类
AtomicIntegerArray：整型数组原子类
AtomicReference<V>：引用数据类型原子类

卖票

class Ticket2 implements Runnable {

    private static AtomicInteger count = new AtomicInteger(100);

    String name;

    public Ticket2(String name) {
        this.name = name;
    }

    @Override
    public void run() {
        while(Ticket2.count.intValue() > 0){
            System.out.println(name + "正在卖票，剩余：" + count.getAndDecrement());
            if(Ticket2.count.intValue() == 0){
                System.out.println("票已售空！！");
                break;
            }
        }
    }
}
public class Ch07 {

    public static void main(String[] args) {
        Ticket2 t1 = new Ticket2("窗口一");
        Ticket2 t2 = new Ticket2("窗口二");
        Ticket2 t3 = new Ticket2("窗口三");

        new Thread(t1).start();
        new Thread(t2).start();
        new Thread(t3).start();
    }
}
不管做什么事，在失败的时候如果还有藉口，那就是还未曾尽过最大的努力。 ——林清玄《越过沧桑》
最后修改：2023 年 01 月 09 日
© 允许规范转载
如果觉得我的文章对你有用，请随意赞赏