Gausst松鼠会

这个屌丝很懒，什么也没留下！

热门标签

Java高并发编程：线程锁技术_java方法加锁还可以并发吗

作者：Gausst松鼠会 | 2024-05-12 21:02:59

踩

java方法加锁还可以并发吗

1 什么是线程锁

实例的全局变量(共享资源)被修改时，会出现线程安全，需要对修改的方法加锁，注意：只要要访问多个线程共享的字段的方法都需要加锁保护。不能前门(方法A)锁上了，后门(方法B)就不锁了，或者窗户(方法C)开着了，这都不行，都必须锁住。
临界区：只允许单个线程执行的程序范围

多线程可以同时运行多个任务

但是当多个线程同时访问共享数据时，可能导致数据不同步，甚至错误！

so,不使用线程锁, 可能导致错误

线程锁技术：Lock & Condition 实现线程同步通信所属包：java.util.concurrent.locks

线程锁	说明
Synchronized	同步方法，锁对象是this；同步静态方法，锁对象是字节码.class；同步代码块，锁对象是任意对象，但必须是同一个对象
Lock	同步锁接口
ReentrantLock	lock()，unlock()，newCondition()
ReadWriteLock	读写锁接口
ReentrantReadWriteLock	readLock()获取读锁，writeLock()获取写锁
Condition	线程间通信 await()等待 signal()唤醒

synchronized和Lock锁的区别

1、synchronized是Java内置的关键字；Lock锁是Java的一个类

2、synchronized无法获取到锁的状态；Lock锁可以判断是否获取到了锁

3、synchronized会自动的释放锁；Lock必须要手动的去释放锁，如果不释放，就会造成死锁

4、synchronized中，线程一在获得锁的情况下阻塞了，第二个线程就只能傻傻的等着；Lock锁出现这种情况，可以使用tryLock()尝试获取锁

5、synchronized是不可中断的、非公平的、可重入锁；Lock锁是非公平的（可以自己设置）、可判断的、可重入锁

6、synchronized适合锁少量的同步代码；Lock锁适合锁大两的同步代码

7、synchronized有代码块锁和方法锁；Lock只有代码块锁

8、使用Lock锁，JVM将花费较少的时间来调度线程，性能更好。并且具有更好的扩展性（拥有更多的子类）

2 synchronized

synchronized是Java语言的关键字，当它用来修饰一个方法或者一个代码块的时候，能够保证在同一时刻最多只有一个线程执行该段代码，也就是保证synchronized内的代码块同步执行，而不会并行执行。

synchronized可以作为代码块使用，也可以直接放在方法(对象方法、静态方法)的签名上。作为代码块必须指定一个对象锁，对象锁就是一个对象，可以是this对象(即调用该方法的实例对象)也可以是自己创建的某个对象，也可以是某个类的字节码对象，synchronized修饰的代码属于原子操作，不可再分割！

作用实例方法时，锁住的是对象的实例(this)
作用静态方法时，锁住的是该类，该 Class所有实例，又因为 Class 的相关数据存储在永久带 PermGen(jdk1.8 则是 metaspace)，永久带是全局共享的，因此静态方法锁相当于类的一个全局锁，会锁所有调用该方法的线程
- 线程A调用一个实例对象非静态Synchronized方法，允许线程B调用该实例对象所属类的静态s方法而不会发生互斥，前者锁的是当前实例对象，后者锁的是当前类
作用于同步代码块锁住的当前对象，进入同步代码块前需要获得对象的锁


// 实例方法使用的是this锁，即调用该对象的实例
synchronized(this) {
    // code
}
 
Object object = new Object();
synchronized(object) {
    // code
}
 
// 静态方法是使用的类锁
synchronized(Xxx.class) {
    // code
}
 
// 对象锁(修饰对象方法，锁为this，即调用该方法的实例对象)
public synchronized void foo() {
}
 
// 类锁(修饰静态方法，锁为这个类，不是某一个对象)
public synchronized static void bar() {
}

当多个线程过来同时执行，如何保证同一时刻只有一个线程在执行(即同步执行)？

synchronized无论作为代码块还是直接修饰方法都会指定一个锁，当一个线程要想执行线程体就必须拿到这个锁，只有拿到锁的线程才能执行，这样只有一个线程能拿到锁，其他线程就拿不到锁，这样其它线程就执行不了，就必须等待，当拿到锁的那个线程执行完就去释放这个锁，这样其它等待的线程就去抢这个锁，哪个线程抢到了锁就去执行，抢不到就继续下一轮的抢。锁分为对象锁和类锁。

在用synchronized关键字的时候，尽量缩小代码块的范围，能在代码段上加同步就不要再整个方法上加同步。减小锁的粒度，使代码更大程度的并发。

1. 对象锁


public class ThisLock {
    public static void main(String[] args) {
        MyRunnable runnable = new MyRunnable();
        System.out.println("runnable=" + runnable);
        new Thread(runnable, "Thread-A").start();
        new Thread(runnable, "Thread-B").start();
    }
}
 
class MyRunnable implements Runnable {
    @Override
    public void run() {
        System.out.println(new Date() + "\t" + Thread.currentThread().getName() + "\t" + this);
        synchronized (this) {
            for(int i = 0; i < 5; i++) {
                System.out.println(new Date() + "\t" + Thread.currentThread().getName() +  "\ti=" + i);
                try { Thread.sleep(1000); } catch (InterruptedException e) { }
            }
        }
    }
}

通过打印结果可以看到this锁就是当前的线程对象runnable，可以看到代码块外的代码是并发执行的，而代码块内部的代码是同步执行的，即同一时刻只有一个线程在执行同步代码块。Thread-A先拿到锁就先执行，直到执行完毕，释放锁，然后Thread-B拿到锁就执行。

示例代码中两个线程都是使用同一个runnable对象，如果两个线程各自使用各自的MyRunnable对象，则是并发的，不会是同步的。


// new Thread(runnable, "Thread-A").start();
// new Thread(runnable, "Thread-B").start();
 
// 锁无效，因为每个new就是一个新的对象，两个线程使用两个不同的锁，达不到互斥的效果
new Thread(new MyRunnable(), "Thread-A").start();
new Thread(new MyRunnable(), "Thread-B").start();

2. 修饰对象方法


public class MethodLock {
    public static void main(String[] args) {
        MyRunnable runnable = new MyRunnable();
        System.out.println("runnable=" + runnable);
        new Thread(runnable, "Thread-A").start();
        new Thread(runnable, "Thread-B").start();
    }
}
 
class MyRunnable implements Runnable {
    @Override
    public void run() {
        System.out.println(new Date() + "\t" + Thread.currentThread().getName() + "\t" + this +  "\trunning...");
        myRun();
    }
 
    private synchronized void myRun() {
        for(int i = 0; i < 4; i++) {
            System.out.println(new Date() + "\t" + Thread.currentThread().getName() +  "\ti=" + i);
            try { Thread.sleep(1000); } catch (InterruptedException e) { }
        }
    }
}

synchronized修饰方法，表示将会锁住整个方法体，锁的是当前对象，这个synchronized(this)代码块包括住方法的所有代码是一样的效果


// 两种方式效果一样
synchronized(this) {
    for(int i = 0; i < 4; i++) {
        System.out.println(new Date() + "\t" + Thread.currentThread().getName() +  "\ti=" + i);
        try { Thread.sleep(1000); } catch (InterruptedException e) { }
    }
}
 
private synchronized void myRun() {
    for(int i = 0; i < 4; i++) {
        System.out.println(new Date() + "\t" + Thread.currentThread().getName() +  "\ti=" + i);
        try { Thread.sleep(1000); } catch (InterruptedException e) { }
    }
}

3. 类锁


public class ClassLock {
    public static void main(String[] args) {
 
        new Thread(new Runnable() {
            @Override
            public void run() {
                ExampleService.test();
            }
        }, "Thread-A").start();
 
 
        new Thread(new Runnable() {
            @Override
            public void run() {
                ExampleService.test2();
            }
        }, "Thread-B").start();
    }
}
 
class ExampleService {
    // 静态方法
    public synchronized static void test() {
        for(int i = 0; i < 4; i++) {
            System.out.println(new Date() + "\t" + Thread.currentThread().getName() +  "\ti=" + i);
            try { Thread.sleep(500); } catch (InterruptedException e) { }
        }
    }
 
    // 静态方法
    public synchronized static void test2() {
        for(int i = 0; i < 4; i++) {
            System.out.println(new Date() + "\t" + Thread.currentThread().getName() +  "\ti=" + i);
        }
    }
}

两个线程分别调用不同的静态方法，两个方法是同步执行，而不是并发执行。因为两个线程都是使用的类锁ExampleService.class, 当Thread-A执行时拿到了ExampleService的类锁，那么Thread-B就拿不到这个类锁了，只有Thread-A执行完毕后释放类锁，Thread-B才能拿到类锁继续执行，所以是同步执行的。

静态同步函数的锁是class对象

4. 对象锁和类锁


public class ObjectClassLock {
    public static void main(String[] args) {
        TestService testService = new TestService();
 
        new Thread(new Runnable() {
            @Override
            public void run() {
                testService.test();
            }
        }, "Thread-A").start();
 
 
        new Thread(new Runnable() {
            @Override
            public void run() {
                testService.test2();
            }
        }, "Thread-B").start();
    }
}
 
class TestService {
    // 锁的是testService这个对象
    public synchronized void test() {
        System.out.println(new Date() + "\t" + Thread.currentThread().getName() + "\t running...");
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println((new Date() + "\t" + Thread.currentThread().getName() + "\t over"));
    }
 
    // 静态是锁的TestService这个类(TestService.class)
    // 对象锁和类锁不是同一个锁，所以两个方法不会互斥
    public synchronized static void test2() {
        System.out.println(new Date() + "\t" + Thread.currentThread().getName() + "\t running...");
        System.out.println((new Date() + "\t" + Thread.currentThread().getName() + "\t over"));
    }
}

Thread-A是访问的对象方法，锁为当前调用者即锁对象为testService，Thread-B虽然是通过对象调用的但是是访问的类方法，锁为类锁，即TestService.class, 因两个线程使用的是不同的锁，自然就互不影响，各自执行各自的，所以是并发执行的，而不是同步执行的。

5. 卖火车票示例


public class TrainTicketTest {
    int num = 2;
    public static void main(String[] args) {
        // 抢火车票功能
        TrainTicketTest synchronizedTest = new TrainTicketTest();
        for (int i = 0; i < 5; i ++) {
            new Thread(synchronizedTest.new TrainTicketThread()).start();
        }
    }
 
    class TrainTicketThread implements Runnable {
        @Override
        public void run() {
            System.out.println(Thread.currentThread().getName() + "\trunning");
            // 模拟业务耗时的时间
            try { Thread.sleep(500);} catch (InterruptedException e) { }
            if (num > 0) {
                System.out.println(Thread.currentThread().getName() + "\t抢到一张票\t目前还有" + num + "张\t");
                int temp = num - 1;
                num = temp;
                System.out.println(Thread.currentThread().getName() + "还剩余" + num + "张");
            }
        }
    }
}

因多线程可能每次运行效果都不同，这里给出一种效果，总共2张票，卖出去3张，卖超了

根据上面的运行结果试图对多线程代码执行分析

出现多卖的原因是由于多线程CPU时间片“随机”的切换，同一段代码被多个线程同时执行，导致值的错乱，解决这种问题的办法就是同一段代码同一时间不允许多个线程执行，也就是只能允许一个线程来执行。
我们可以为代码加上一个锁，哪个线程想要执行这段代码必须手里拿着锁才能执行，当执行完毕就把锁丢出去，其它线程如果想要执行就必须抢到锁(注意多个线程必须使用同一个锁)，只有抢到锁了才能执行加锁的代码，为代码加锁有两种方式synchronized和lock，锁就是一个对象。


public class TrainTicketTest {
    // 全局变量，必须保证所有线程都在使用同一个锁
    Object object = new Object();
    int num = 2;
 
    public static void main(String[] args) {
        // 抢火车票功能
        TrainTicketTest synchronizedTest = new TrainTicketTest();
        for (int i = 0; i < 5; i ++) {
            new Thread(synchronizedTest.new TrainTicketThread()).start();
        }
    }
 
    class TrainTicketThread implements Runnable {
        @Override
        public void run() {
            System.out.println(Thread.currentThread().getName() + "running");
            try { Thread.sleep(500);} catch (InterruptedException e) { }
            synchronized (object) {
                if (num > 0) {
                    System.out.println(Thread.currentThread().getName() + "\t抢到一张票\t目前还有" + num + "张\t");
                    int temp = num - 1;
                    num = temp;
                    System.out.println(Thread.currentThread().getName() + "还剩余" + num + "张");
                }
            }
        }
    }
}


public class TrainTicket2Test {
    int num = 2;
    public static void main(String[] args) {
        // 抢火车票功能
        TrainTicket2Test synchronizedTest = new TrainTicket2Test();
        for (int i = 0; i < 5; i ++) {
            new Thread(synchronizedTest.new TrainTicketThread()).start();
        }
    }
 
    class TrainTicketThread implements Runnable {
        @Override
        public void run() {
            getTrainTicket();
        }
    }
 
    private synchronized void getTrainTicket() {
        System.out.println(Thread.currentThread().getName() + "running");
        try { Thread.sleep(500);} catch (InterruptedException e) { }
        if (num > 0) {
            System.out.println(Thread.currentThread().getName() + "\t抢到一张票\t目前还有" + num + "张\t");
            int temp = num - 1;
            num = temp;
            System.out.println(Thread.currentThread().getName() + "还剩余" + num + "张");
        }
    }
}

分别是

Thread-0running
Thread-1running
Thread-4running
Thread-3running
Thread-2running
Thread-0 抢到一张票目前还有2张
Thread-0还剩余1张
Thread-1 抢到一张票目前还有1张
Thread-1还剩余0张

Thread-0running
Thread-0 抢到一张票目前还有2张
Thread-0还剩余1张
Thread-4running
Thread-4 抢到一张票目前还有1张
Thread-4还剩余0张
Thread-3running
Thread-2running
Thread-1running

三个人在不停的过一个门，一个门一次只能通过一个，每通过一个人就记录通过的总人数及最后通过的人的姓名和地址。

Gate: 模拟门类


public class Gate {
    private int counter = 0;
    private String name = "Noboday";
    private String address = "Nowhere";
 
    public synchronized void pass(String name, String addrees) {
        this.counter++;
        this.name = name;
        this.address = addrees;
        check();
    }
 
 
    private void check() {
        if (name.charAt(0) != address.charAt(0)) {
            System.out.println("****BROKEN****" + toString());
        }
    }
 
    @Override
    public synchronized String toString() {
        return "No." + counter + ":" + name + "," + address;
    }
}

UserThread: 模拟人不停的过门


public class UserThread extends Thread {
    private final Gate gate;
    private final String myName;
    private final String myAddress;
 
    public UserThread(Gate gate, String myName, String myAddress){
        this.gate = gate;
        this.myName = myName;
        this.myAddress = myAddress;
    }
 
    @Override
    public void run() {
        System.out.println(myName + "BEGIN");
        while (true) {
            gate.pass(myName, myAddress);
        }
    }
}

Main: 三个人不停的过门，为了便于区分，每个人的姓名和地址首字母是相同的


public class Main {
    public static void main(String[] args) {
        Gate gate = new Gate();
 
        // 3个人过的是同一个门gate，即synchronized修饰方法=synchronized(this)=synchronized(gate)
        // 3个人是使用的同一把gate锁
        new UserThread(gate, "Alice", "Alaska").start();
        new UserThread(gate, "Bobby", "Brazil").start();
        new UserThread(gate, "Chris", "Canada").start();
    }
}

去掉Gate类中的pass和toString方法的synchronized，运行效果如图

Alice, Canada: Thread-0先执行this.name = name, 此时name=Chris, 此时CPU切换到Thread-1，然后执行了this.name = name; this.address = address; 此时name=Alice, address= Alaska; 此时CPU切换到Thread-0的address赋值，此时address=Canada, 所以最终的name=Alice,address=Canada, 两个值状态不一致。
Bobby,Brazil: 假如Thread-0是Bobby，假如Thread-0先执行this.name = name; 此时name=bobby;此时CPU切换到Thread-1, 假如Thread-1是Chris，Thread分别执行了给name和address分别赋值，此时name=Chris,address=Canada, 然后CPU切回到Thread-0,执行this.address=address, 此时adress为Brazil, 接着Thread-0又执行完了check()方法，此时CPU又切到Thread-1执行，开始执行check()方法，但是这个方法并没有一下子执行完，而是执行到if(name.charAt(0) != address.charAt(0))这个判断的时候又切到Thread-0了，注意此时没有没有执行if体中的代码，只是仅仅执行了条件判断，此时还没有进入if体就被切走了，切到Thread-0执行this.name=name,此时name=Bobby，此时又被切到Thread-1，执行刚才的if体，一打印，结果name=Bobby,address=Brazil, 这种问题的出现就是if判断和if体分开执行了，当再次执行if体的时候结果字段的值改变了

为什么toString方法也加锁？
所有访问或者操作多线程共享的全局变量时都应该加锁。

6. 生产一个消费一个示例

生产一个就要消费一个，消费不完不能生产。此示例生产者和消费者线程使用的是同一个对象锁person

wait和notify通常操作的是锁对象

wait的作用：暂停线程执行，将当前线程的状态置为阻塞状态，并释放锁
notify的作用：随机将调用notify方法的对象所对应的线程的状态置为就绪状态


public class MQExample {
 
    public static void main(String[] args) {
        Person person = new Person();
        new Thread(new Producer(person)).start();
        new Thread(new Consumer(person)).start();
    }
}
 
class Producer implements Runnable {
    private Person person;
    public Producer(Person person) {
        this.person = person;
    }
 
    @Override
    public void run() {
        synchronized (person) {
            int i = 0;
            while (true) {
                if (i % 2 == 0) {
                    person.setName("小红");
                    person.setGender("女");
                } else {
                    person.setName("小明");
                    person.setGender("男");
                }
                System.out.println(new Date() + "\t生产者生产了一个对象【" + person.getName() + ", " + person.getGender() +"】");
                i++;
 
                // 当生产完一个要释放锁
                try {
                    person.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
 
                System.out.println("----------------------------------------------------------");
                person.notify();
            }
        }
    }
}
 
class Consumer implements Runnable {
    private Person person;
 
    public Consumer(Person person) {
        this.person = person;
    }
 
    @Override
    public void run() {
        synchronized (person) {
            while (true) {
                System.out.println(new Date() + "\t消费者消费了一个对象《" + person.getName() + ", " + person.getGender() + "》");
                person.notify();
 
                try {
                    person.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}
 
class Person {
    private String name;
    private String gender;
 
    public String getName() {
        return name;
    }
 
    public void setName(String name) {
        this.name = name;
    }
 
    public String getGender() {
        return gender;
    }
 
    public void setGender(String gender) {
        this.gender = gender;
    }
}

循环执行以上

该代码比较绕，进行分析一下

首先启动Producer生产者线程，进入run()方法拿到person锁，执行第一次while循环，打印【小红, 女】，执行person.wait()暂停当前线程执行，释放person对象锁
因Producer生产者线程在执行person.wait()释放了锁，而且生产者线程还被阻塞了，此时CPU该执行消费者线程Consumer，消费者线程能拿到person对象锁，就可以进入同步代码块从而执行第一个循环打印《小红, 女》，接下来执行person.notify() 会唤醒生产者线程Producer，将生产者线程的状态从阻塞状态设置为就绪状态，再接下来执行消费者的person.wait()，这行代码让消费者线程暂停执行，同时释放person锁
消费者因执行person.wait()导致消费者线程释放了person对象锁而且使消费者暂停执行，从而CPU就有机会执行生产者线程了，生成者能拿到person对象锁，而且当前状态为就绪状态，就有资格进入运行状态，此时生产者线程会接着上次没有执行完的代码继续执行，所以就执行了打印“——-”，接着执行生产者线程中的person.notify();此行代码的作用是让消费者置为就绪状态，此时因为生产者还持有锁，虽然消费者线程置为就绪状态，因拿不到锁，所以不具备运行的条件。当执行完生产者的person.notify();这行代码时，此时第一轮循环就结束了，接着继续循环第二轮，就继续打印【小明, 男】，然后执行person.wait()暂停当前线程执行，释放person对象锁，就这样步骤2，步骤3 一下循环下去执行

注意：Object.wait()和Object.notify() 只能用在同步方法或者同步代码块中synchronized

3 Lock

Lock比传统线程模型中的synchronized方式更加面向对象，相对于synchronized 方法和语句它具有更广泛的锁定操作，此实现允许更灵活的结构，可以具有差别很大的属性，可以支持多个相关的 Condition 对象。

于现实生活中类似，锁本身也是一个对象。两个线程执行的代码片段要实现同步互斥的结果，它们必须用同一个Lock对象，锁是上在代表要操作的资源的类的内部方法中，而不是线程代码中。

Lock需要手动加锁，释放锁也需要手动释放，释放锁最好(必须)放到finally代码块中释放。
注意：同一个锁可以加锁多次(调用多次lock() )，相应的加N次锁也必须解N次锁(unlock())，一般情况下都是加一次锁和解一次锁


package java.util.concurrent.locks;
 
public interface Lock {
    // 加锁
    void lock();
    void lockInterruptibly() throws InterruptedException;
    boolean tryLock();
    boolean tryLock(long time, TimeUnit unit) throws InterruptedException;
    // 释放锁
    void unlock();
    Condition newCondition();
}

3.1 重入锁 ReentrantLock


package java.util.concurrent.locks;
public class ReentrantLock implements Lock, java.io.Serializable {
    public boolean isLocked();
}

方法声明	功能描述
lock()	获取锁
tryLock()	尝试获取锁
unock()	释放锁
newCondition()	获取锁的Condition

常用形式如下


public class ReentrantLockTest {
    public static void main(String[] args) {
        Lock lock = new ReentrantLock();
 
        Runnable runnable = () -> {
            System.out.println(new Date() + "\t" + Thread.currentThread().getName() + "\trunning...");
            lock.lock();
            try {
                for(int i = 0; i < 4; i++) {
                    System.out.println(new Date() + "\t" + Thread.currentThread().getName() +  "\ti=" + i);
                    try { Thread.sleep(1000); } catch (InterruptedException e) { }
                }
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                lock.unlock();
            }
        };
 
        new Thread(runnable, "Thread-A").start();
        new Thread(runnable, "Thread-B").start();
    }
}

使用ReentrantLock和使用synchronized 代码块都能达到上锁的目的。先执行Thread-A线程，当指定到lock.lock()当前线程就拿到锁，然后执行线程体，最后执行lock.unlock()释放锁，这样Thread-B就能拿到线程继续执行。

3.2 读写锁

分为读锁和写锁，多个读锁不互斥，读锁与写锁互斥，写锁与写锁互斥，这是由JVM自己控制的。你只要上好相应的锁即可。如果你的代码只读数据，可以很多人同时读，但不能同时写，那就上读锁；如果你的代码修改数据，只能有一个人在写，且不能同时读取，那就上写锁。总之，读的时候上读锁，写的时候上写锁！

读写锁的使用情景：

如果代码只读数据，就可以很多人共同读取，但不能同时写。
如果代码修改数据，只能有一个人在写，且不能同时读数据。


public class ReadWriteLockTest {
    private volatile static Map<String, Object> cacheMap = new HashMap<>();
    private static ReentrantReadWriteLock readWriteLock = new ReentrantReadWriteLock();
    static ReentrantReadWriteLock.ReadLock readLock = readWriteLock.readLock();
    static ReentrantReadWriteLock.WriteLock writeLock = readWriteLock.writeLock();
 
    public static void main(String[] args) {
 
        // 写的时候不能读，读的时候不能写，写的时候不能写，读的时候可以读
        new Thread(() -> {
            for(int i = 0;i < 5; i++) {
                put(i + "", i);
            }
        }).start();
 
        new Thread(() -> {
            for(int i = 0; i < 5; i++) {
                get(i + "");
            }
        }).start();
 
        new Thread(() -> {
            for(int i = 0;i < 5; i++) {
                put(i + "", i);
            }
        }).start();
    }
 
    public static Object put(String key, Object value) {
        try {
            writeLock.lock();
            System.out.println(new Date() + "\t" + Thread.currentThread().getName() + "\t写\t" + key + "=" + value + "\tstart...");
            try { Thread.sleep(1000); } catch (InterruptedException e) { }
            cacheMap.put(key, value);
            System.out.println(new Date() + "\t" + Thread.currentThread().getName() + "\t写\t" + key + "=" + value + "\tend");
        } catch (Exception e) {
        } finally {
            writeLock.unlock();
        }
 
        return value;
    }
 
    public static Object get(String key) {
        try {
            readLock.lock();
            System.out.println(new Date() + "\t" + Thread.currentThread().getName() + "\t读\t" + key + "\tstart...");
            try { Thread.sleep(1000); } catch (InterruptedException e) { }
            Object value = cacheMap.get(key);
            System.out.println(new Date() + "\t" + Thread.currentThread().getName() + "\t读\t" + key + "\tend");
            return value;
        } catch (Exception e) {
        } finally {
            readLock.unlock();
        }
 
        return null;
    }
}

4 Condition

用于实现线程间的通信，是为了解决Object.wait()、nitify()、notifyAll()难以使用的问题

Condition 将 Object 监视器方法（wait、notify 和 notifyAll）分解成截然不同的对象，以便通过将这些对象与任意 Lock 实现组合使用，为每个对象提供多个等待 set（wait-set）。其中，Lock 替代了 synchronized 方法和语句的使用，Condition 替代了 Object 监视器方法wait和notify的使用

一个锁内部可以有多个Condition，即有多路等待通知，传统的线程机制中一个监视器对象上只能有一路等待和通知，要想实现多路等待和通知，必须嵌套使用多个同步监视器对象。使用一个监视器往往会产生顾此失彼的情况。

在等待 Condition 时，允许发生“虚假唤醒”，这通常作为对基础平台语义的让步。对于大多数应用程序，这带来的实际影响很小，因为 Condition 应该总是在一个循环中被等待，并测试正被等待的状态声明。某个实现可以随意移除可能的虚假唤醒，但建议应用程序程序员总是假定这些虚假唤醒可能发生，因此总是在一个循环中等待。

方法声明	功能描述
await()	线程等待
await(long time, TimeUnit unit)	线程等待特定的时间，超过等待时间则为超时
signal()	随机唤醒某个等待线程
signalAll()	唤醒所有等待中的线程

示例1

Object.wait和notify只能用于synchronized，如果想使用Lock就需要使用Condition来代替


public interface Condition {
    // 等待，相当于Object.wait()
    void await() throws InterruptedException;
    long awaitNanos(long nanosTimeout) throws InterruptedException;
    boolean await(long time, TimeUnit unit) throws InterruptedException;
 
    // 唤醒，相当于Object.notify()
    void signal();  
    void signalAll();
}

ConditionTest


public class ConditionTest {
    public static void main(String[] args) throws InterruptedException {
        // 多个线程必须使用相同的锁和条件
        Lock lock = new ReentrantLock();
        Condition condition = lock.newCondition();
        System.out.println(condition);
 
        new Thread(new MyRunnable(lock, condition), "Thread-A").start();
        Thread.sleep(1000);
        new Thread(new MyRunnable2(lock, condition), "Thread-B").start();
    }
}
 
class MyRunnable implements Runnable {
    private Lock lock;
    private Condition condition;
    public MyRunnable(Lock lock, Condition condition) {
        this.lock = lock;
        this.condition = condition;
    }
 
    @Override
    public void run() {
        System.out.println(new Date() + "\t" + Thread.currentThread().getName() + "\t开始等待>>>");
        lock.lock();
        try {
            condition.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
        System.out.println(new Date() + "\t" + Thread.currentThread().getName() + "\t已 苏 醒^_^");
    }
}
 
class MyRunnable2 implements Runnable {
    private Lock lock;
    private Condition condition;
    public MyRunnable2(Lock lock, Condition condition) {
        this.lock = lock;
        this.condition = condition;
    }
 
    @Override
    public void run() {
        lock.lock();
        try {
            System.out.println(new Date() + "\t" + Thread.currentThread().getName() + "\t开始通知...");
            condition.signal();
            System.out.println(new Date() + "\t" + Thread.currentThread().getName() + "\t通知完成。。。");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
}

这里写图片描述

示例2

一共有3个线程，两个子线程先后循环2次，接着主线程循环3次，接着又回到两个子线程先后循环2次，再回到主线程又循环3次，如此循环5次。

思路：老二先执行，执行完唤醒老三，老三执行完唤醒老大，老大执行完唤醒老二，以此循环，所以定义3个Condition对象和一个执行标识即可

示例出现的问题：两个文件中有同名类的情况

解决方案：可以将一个文件中的那个同名外部类放进类中，但是静态不能创建内部类的实例对象，所以需要加上static，这样两个类的名称就不一样了。一个是原来的类名，一个是在自己类名前面加上外部类的类名。


import java.util.concurrent.locks.Condition;  
import java.util.concurrent.locks.Lock;  
import java.util.concurrent.locks.ReentrantLock;  
 
public class ThreeConditionCommunication {  
    public static void main(String[] args){  
 
        final Business business = new Business();  
 
　　     //创建并启动子线程老二  
        new Thread(new Runnable(){  
            @Override  
            public void run() {  
                for(int i=1;i<=5;i++){  
                    business.sub2(i);  
                }  
            }  
        }).start();  
 
　　     //创建并启动子线程老三  
        new Thread(new Runnable(){  
            @Override  
            public void run() {  
                for(int i=1;i<=5;i++){  
                    business.sub3(i);  
                }  
            }  
        }).start();  
 
            //主线程  
            for(int i=1;i<=5;i++){  
                business.main(i);  
          }  
       }  
 
    static class Business{  
 
        Lock lock = new ReentrantLock();   
        Condition condition1 = lock.newCondition();  
        Condition condition2 = lock.newCondition();  
        Condition condition3 = lock.newCondition();  
 
        //定义一个变量来决定线程的执行权  
        private int ShouldSub = 1;  
 
        public  void  sub2(int i){  
            //上锁，不让其他线程执行  
            lock.lock();  
            try{  
            if(ShouldSub != 2){ //如果不该老二执行，就等待  
                try {  
                    condition2.await();  
                } catch (InterruptedException e) {  
                    e.printStackTrace();  
                }  
            }  
 
            for(int j=1;j<=2;j++){  
                System.out.println("sub thread sequence of"+i+",loop of "+j);  
            }  
            ShouldSub = 3;  //准备让老三执行  
            condition3.signal();        //唤醒老三  
            }finally{  
                lock.unlock();  
            }     
        }  
 
        public  void  sub3(int i){  
 
            lock.lock();  
            try{  
            if(ShouldSub != 3){  
                try {  
                    condition3.await();  
                } catch (InterruptedException e) {  
                    e.printStackTrace();  
                }  
            }  
 
            for(int j=1;j<=2;j++){  
                System.out.println("sub2 thread sequence of"+i+",loop of "+j);  
            }  
                ShouldSub = 1;  //准备让老大执行  
                condition1.signal();        //唤醒老大  
            }finally{  
                lock.unlock();  
            }  
        }  
 
　　    //主线程  
        public  void main(int i){  
 
            lock.lock();  
            try{  
            if(ShouldSub!=1){  
                try {  
                    condition1.await();  
                } catch (InterruptedException e) {  
                    e.printStackTrace();  
                }  
            }  
            for(int j=1;j<=3;j++){  
                System.out.println("main thread sequence of"+i+", loop of "+j);  
            }     
            ShouldSub = 2;  //准备让老二执行  
            condition2.signal();        //唤醒老二  
            }finally{  
                lock.unlock();  
            }     
        }     
    }  
   }


main thread sequence of1, loop of 1
main thread sequence of1, loop of 2
main thread sequence of1, loop of 3
sub thread sequence of1,loop of 1
sub thread sequence of1,loop of 2
sub2 thread sequence of1,loop of 1
sub2 thread sequence of1,loop of 2
main thread sequence of2, loop of 1
main thread sequence of2, loop of 2
main thread sequence of2, loop of 3
sub thread sequence of2,loop of 1
sub thread sequence of2,loop of 2
sub2 thread sequence of2,loop of 1
sub2 thread sequence of2,loop of 2
main thread sequence of3, loop of 1
main thread sequence of3, loop of 2
main thread sequence of3, loop of 3
sub thread sequence of3,loop of 1
sub thread sequence of3,loop of 2
sub2 thread sequence of3,loop of 1
sub2 thread sequence of3,loop of 2
main thread sequence of4, loop of 1
main thread sequence of4, loop of 2
main thread sequence of4, loop of 3
sub thread sequence of4,loop of 1
sub thread sequence of4,loop of 2
sub2 thread sequence of4,loop of 1
sub2 thread sequence of4,loop of 2
main thread sequence of5, loop of 1
main thread sequence of5, loop of 2
main thread sequence of5, loop of 3
sub thread sequence of5,loop of 1
sub thread sequence of5,loop of 2
sub2 thread sequence of5,loop of 1
sub2 thread sequence of5,loop of 2

5 死锁

一个线程中有多个锁，多个线程同时执行，可能线程1获得A锁，线程2获得了B锁，然后线程A想得到B锁就一直等待有人释放，线程2想得到Asuo就等待两个人一直等待，两个线程各自持有一个，而且只有某个线程同时拥有AB锁才能执行，两个人都只得到一个，却谁都不愿意释放，导致两个线程都在等待。
就像一个门同时需要两把钥匙同时打开，张三拿一把，李四拿一把，他们两个谁都不把自己的那把给对方，张三说“李四你先把你的那把给我，我用户就还你”，李四说“张三你先把你的那把给我，我用户就还你”，两个人都比较固执，结果两个人一直僵持着


public class DeadLockTest {
    public static String a = "a";
    public static String b = "b";
 
    public static void main(String[] args) {
        new Thread(new MyTask0()).start();
        new Thread(new MyTask1()).start();
    }
}
 
class MyTask0 implements Runnable {
    @Override
    public void run() {
        System.out.println(new Date() + "\t" + Thread.currentThread().getName() + "\t running...");
        synchronized (DeadLockTest.a) {
            System.out.println(new Date() + "\t" + Thread.currentThread().getName() + "\t first synchronized ...");
            try { Thread.sleep(1000); } catch (InterruptedException e) { }
 
            synchronized (DeadLockTest.b) {
                System.out.println(new Date() + "\t" + Thread.currentThread().getName() + "\t second synchronized ...");
            }
        }
    }
}
 
class MyTask1 implements Runnable {
    @Override
    public void run() {
        System.out.println(new Date() + "\t" + Thread.currentThread().getName() + "\t running...");
        synchronized (DeadLockTest.b) {
            System.out.println(new Date() + "\t" + Thread.currentThread().getName() + "\t first synchronized ...");
            try { Thread.sleep(1000); } catch (InterruptedException e) { }
 
            synchronized (DeadLockTest.a) {
                System.out.println(new Date() + "\t" + Thread.currentThread().getName() + "\t second synchronized...");
            }
        }
    }
}

两个线程的第二个代码块都没有执行，main方法也一直在运行状态，没有结束。

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/Gausst松鼠会/article/detail/560582