JUC学习笔记三

作者: Martain | 来源:发表于2020-07-14 19:20 被阅读0次

JUC学习笔记三

用于解决多线程同步问题的方式

隐式锁（`synchronized`）

同步代码块
同步方法

显式锁(`JDK 1.5 以后`)

同步锁Lock
读写锁 ReadWriteLock

需要通过lock() 方法上锁，必须通过 unlock()方法进行释放锁

同步锁实例：卖票

public class TestLock {
    
    public static void main(String[] args) {
        Ticket ticket = new Ticket();
    /**
        * 创建3个线程卖票
        */
        new Thread(ticket, "1号窗口").start();
        new Thread(ticket, "2号窗口").start();
        new Thread(ticket, "3号窗口").start();
    }
}

class Ticket implements Runnable{
    
    private int tick = 100;
    private Lock lock = new ReentrantLock();

    @Override
    public void run() {
        while(true){
            
            lock.lock(); //上锁
            try{
                if(tick > 0){
                    try {
                        Thread.sleep(200);
                    } catch (InterruptedException e) {
                    }
                    
        System.out.println(Thread.currentThread().getName() + " 完成售票，余票为：" + --tick);
                }
            }finally{
                lock.unlock(); //释放锁
            }
        }
    }
    
}

生产者消费者问题

实例

public class ProductorAndConsumerTest {
    public static void main(String[] args) {
        final Clerk clerk = new Clerk();
        Productor productor = new Productor(clerk);
        Consumer consumer = new Consumer(clerk);
        new Thread(productor,"生产者 A").start();
        new Thread(consumer,"消费者 B").start();
    }
}

/**
 * 模拟店员
 */
class Clerk{
    private int product = 0;

    /**
     * 模拟进货
     * 因为涉及共享数据，所以这里使用同步代码块
     */
    public synchronized void get(){
        if (product>=10){
            System.out.println("仓库已满");
        }else {
            System.out.println(Thread.currentThread().getName()+":"+ ++product);
        }
    }

    /**
     * 模拟销售
     * 因为涉及共享数据，所以这里使用同步代码块
     */
    public synchronized void sale(){
        if (product<=0){
            System.out.println("产品缺货");
        }else {
            System.out.println(Thread.currentThread().getName()+":"+ --product);
        }
    }
}

/**
 * 模拟生产者
 */
class Productor implements Runnable{
    private Clerk clerk;

    public Productor(Clerk clerk) {
        this.clerk = clerk;
    }

    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            clerk.get();
        }
    }
}

/**
 * 模拟消费者
 */
class Consumer implements Runnable{
    private Clerk clerk;

    public Consumer(Clerk clerk) {
        this.clerk = clerk;
    }

    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            clerk.sale();
        }
    }
}

生产者 A:1
生产者 A:2
生产者 A:3
生产者 A:4
生产者 A:5
生产者 A:6
生产者 A:7
生产者 A:8
生产者 A:9
生产者 A:10
仓库已满
仓库已满
仓库已满
仓库已满
仓库已满
仓库已满
仓库已满
仓库已满
仓库已满
仓库已满
消费者 B:9
消费者 B:8
消费者 B:7
消费者 B:6
消费者 B:5
消费者 B:4
消费者 B:3
消费者 B:2
消费者 B:1
消费者 B:0
产品缺货
产品缺货
产品缺货
产品缺货
产品缺货
产品缺货
产品缺货
产品缺货
产品缺货
产品缺货

我们发现，当仓库已满的时候，线程还在继续生产，当商品已经没有了的时候，消费者仍然一直在购买。

等待唤醒机制

在一个消费者一个生产者线程的案例中，我们可以使用Object的wait和notifyAll方法来完成等待和唤醒机制，实现有效的生产和消费。

/**
 * 模拟店员
 */
class Clerk{
    private int product = 0;

    /**
     * 模拟进货
     * 因为涉及共享数据，所以这里使用同步代码块
     */
    public void get(){
        if (product>=10){
            System.out.println("仓库已满");
            try {
                /**
                 * 等待消费者通知
                 * 等消费了商品可以放下了再生产
                 */
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }else {
            System.out.println(Thread.currentThread().getName()+":"+ ++product);
            /**
             * 通知消费者
             * 通知消费者已经有商品可以购买了
             */
            this.notifyAll();
        }
    }

    /**
     * 模拟销售
     * 因为涉及共享数据，所以这里使用同步代码块
     */
    public synchronized void sale(){
        if (product<=0){
            System.out.println("产品缺货");
            try {
                /**
                 * 等待生产者
                 * 等待生产者有商品了
                 */
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }else {
            System.out.println(Thread.currentThread().getName()+":"+ --product);
            /**
             * 通知生产者
             * 通知生产者可以生产了
             */
            this.notifyAll();
        }
    }
}

生产者 A:1
生产者 A:2
生产者 A:3
生产者 A:4
生产者 A:5
生产者 A:6
生产者 A:7
生产者 A:8
生产者 A:9
生产者 A:10
仓库已满
消费者 B:9
消费者 B:8
消费者 B:7
消费者 B:6
消费者 B:5
消费者 B:4
消费者 B:3
消费者 B:2
消费者 B:1
消费者 B:0
产品缺货
生产者 A:1
生产者 A:2
生产者 A:3
生产者 A:4
生产者 A:5
生产者 A:6
生产者 A:7
生产者 A:8
生产者 A:9
消费者 B:8
消费者 B:7
消费者 B:6
消费者 B:5
消费者 B:4
消费者 B:3
消费者 B:2
消费者 B:1
消费者 B:0

从结果中来看还是比较正常的，但是如果生产者有些耗时，会导致存在某个情况无法wait方法没有线程去唤醒的话，会导致程序一直在等待中，所以需要注意,上面这个列子只要去掉get和sale方法中else即可解决。

/**
 * 模拟店员
 */
class Clerk{
    private int product = 0;

    /**
     * 模拟进货
     * 因为涉及共享数据，所以这里使用同步代码块
     */
    public synchronized void get(){
        if (product>=1){
            System.out.println("仓库已满");
            try {
                /**
                 * 等待消费者通知
                 * 等消费了商品可以放下了再生产
                 */
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        /**
         * 当有空位或者等待到消费者消费空出了位置
         */
        System.out.println(Thread.currentThread().getName()+":"+ ++product);
        /**
         * 通知消费者
         * 通知消费者已经有商品可以购买了
         */
        this.notifyAll();
    }

    /**
     * 模拟销售
     * 因为涉及共享数据，所以这里使用同步代码块
     */
    public synchronized void sale(){
        if (product<=0){
            System.out.println("产品缺货");
            try {
                /**
                 * 等待生产者
                 * 等待生产者有商品了
                 */
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        /**
         * 当有货或者等待到有货之后，可以消费
         */
        System.out.println(Thread.currentThread().getName()+":"+ --product);
        /**
         * 通知生产者
         * 通知生产者可以生产了
         */
        this.notifyAll();
    }
}

虚假唤醒

当多个生产者线程和多个消费者线程，假设有多个消费者线程在等待，这个时候一个生产者生产了一个商品，发出通知的信号，导致这多个线程去消费这个商品，会导致库存为负数，这个就是虚假唤醒,官方给出的解决方案就是要避免虚假唤醒，应该总是让代码块使用在循环中，改动如下

/**
 * 模拟店员
 */
class Clerk{
    private int product = 0;

    /**
     * 模拟进货
     * 因为涉及共享数据，所以这里使用同步代码块
     */
    public synchronized void get(){
        while (product>=10){
            System.out.println("仓库已满");
            try {
                /**
                 * 等待消费者通知
                 * 等消费了商品可以放下了再生产
                 */
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        /**
         * 当有空位或者等待到消费者消费空出了位置
         */
        System.out.println(Thread.currentThread().getName()+":"+ ++product);
        /**
         * 通知消费者
         * 通知消费者已经有商品可以购买了
         */
        this.notifyAll();
    }

    /**
     * 模拟销售
     * 因为涉及共享数据，所以这里使用同步代码块
     */
    public synchronized void sale(){
        while (product<=0){
            System.out.println("产品缺货");
            try {
                /**
                 * 等待生产者
                 * 等待生产者有商品了
                 */
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        /**
         * 当有货或者等待到有货之后，可以消费
         */
        System.out.println(Thread.currentThread().getName()+":"+ --product);
        /**
         * 通知生产者
         * 通知生产者可以生产了
         */
        this.notifyAll();
    }
}

使用同步锁

Condition 控制线程通信

Condition接口描述了可能会与锁有关联的条件变量。这些变量在用法上与使用 Object.wait访问的隐式监视器类似，但提供了更强大的功能。需要特别指出的是，单个 Lock 可能与多个 Condition 对象关联。为了避免兼容性问题，Condition方法的名称与对应的 Object 版本中的不同。

在 Condition对象中，与 wait、 notify 和 notifyAll方法对应的分别是await、 signal和 signalAll。

Condition 实例实质上被绑定到一个锁上。要为特定 Lock 实例获得Condition实例，请使用其 newCondition()方法。

/**
 * 模拟店员
 */
class Clerk2{
    private int product = 0;

    /**
     * 使用同步锁
     */
    private Lock lock = new ReentrantLock();
    private Condition condition = lock.newCondition();

    /**
     * 模拟进货
     * 因为涉及共享数据，所以这里使用同步代码块
     */
    public synchronized void get(){
        lock.lock();
        try{
            while (product>=10){
                System.out.println("仓库已满");
                try {
                    /**
                     * 等待消费者通知
                     * 等消费了商品可以放下了再生产
                     */
                    this.condition.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            /**
             * 当有空位或者等待到消费者消费空出了位置
             */
            System.out.println(Thread.currentThread().getName()+":"+ ++product);
            /**
             * 通知消费者
             * 通知消费者已经有商品可以购买了
             */
            this.condition.signalAll();
        }finally {
            lock.unlock();
        }
    }

    /**
     * 模拟销售
     * 因为涉及共享数据，所以这里使用同步代码块
     */
    public synchronized void sale(){
        lock.lock();
        try {
            while (product<=0){
                System.out.println("产品缺货");
                try {
                    /**
                     * 等待生产者
                     * 等待生产者有商品了
                     */
                    this.condition.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            /**
             * 当有货或者等待到有货之后，可以消费
             */
            System.out.println(Thread.currentThread().getName()+":"+ --product);
            /**
             * 通知生产者
             * 通知生产者可以生产了
             */
            this.condition.signalAll();
        }finally {
            lock.unlock();
        }

    }
}

线程按序交替

编写一个程序，开启 3 个线程，这三个线程的 ID 分别为 A、B、C，每个线程将自己的 ID 在屏幕上打印 10 遍，要求输出的结果必须按顺序显示。

如：ABCABCABC…… 依次递归

/*
* 编写一个程序，开启 3 个线程，这三个线程的 ID 分别为 A、B、C，每个线程将自己的 ID 在屏幕上打印 10 遍，要求输出的结果必须按顺序显示。
*  如：ABCABCABC…… 依次递归
*/
public class TestABCAlternate {
   
   public static void main(String[] args) {
       AlternateDemo ad = new AlternateDemo();
       
       new Thread(new Runnable() {
           @Override
           public void run() {
               
               for (int i = 1; i <= 20; i++) {
                   ad.loopA(i);
               }
               
           }
       }, "A").start();
       
       new Thread(new Runnable() {
           @Override
           public void run() {
               
               for (int i = 1; i <= 20; i++) {
                   ad.loopB(i);
               }
               
           }
       }, "B").start();
       
       new Thread(new Runnable() {
           @Override
           public void run() {
               
               for (int i = 1; i <= 20; i++) {
                   ad.loopC(i);
                   
                   System.out.println("-----------------------------------");
               }
               
           }
       }, "C").start();
   }

}

class AlternateDemo{
   
   private int number = 1; //当前正在执行线程的标记
   
   private Lock lock = new ReentrantLock();
 
 // 控制3个线程，所以创建3个condition
   private Condition condition1 = lock.newCondition();
   private Condition condition2 = lock.newCondition();
   private Condition condition3 = lock.newCondition();
   
   /**
    * @param totalLoop : 循环第几轮
    */
   public void loopA(int totalLoop){
       lock.lock();
       
       try {
           //1. 判断
           if(number != 1){
               condition1.await();
           }
           
           //2. 打印
           for (int i = 1; i <= 1; i++) {
               System.out.println(Thread.currentThread().getName() + "\t" + i + "\t" + totalLoop);
           }
           
           //3. 唤醒
           number = 2;
           condition2.signal();
       } catch (Exception e) {
           e.printStackTrace();
       } finally {
           lock.unlock();
       }
   }
   
   public void loopB(int totalLoop){
       lock.lock();
       
       try {
           //1. 判断
           if(number != 2){
               condition2.await();
           }
           
           //2. 打印
           for (int i = 1; i <= 1; i++) {
               System.out.println(Thread.currentThread().getName() + "\t" + i + "\t" + totalLoop);
           }
           
           //3. 唤醒
           number = 3;
           condition3.signal();
       } catch (Exception e) {
           e.printStackTrace();
       } finally {
           lock.unlock();
       }
   }
   
   public void loopC(int totalLoop){
       lock.lock();
       
       try {
           //1. 判断
           if(number != 3){
               condition3.await();
           }
           
           //2. 打印
           for (int i = 1; i <= 1; i++) {
               System.out.println(Thread.currentThread().getName() + "\t" + i + "\t" + totalLoop);
           }
           
           //3. 唤醒
           number = 1;
           condition1.signal();
       } catch (Exception e) {
           e.printStackTrace();
       } finally {
           lock.unlock();
       }
   }
   
}

读写锁

ReadWriteLock 维护了一对相关的锁，一个用于只读操作，另一个用于写入操作。只要没有 writer，读取锁可以由多个 reader 线程同时保持。写入锁是独占的。

ReadWriteLock 读取操作通常不会改变共享资源，但执行写入操作时，必须独占方式来获取锁。对于读取操作占多数的数据结构。 ReadWriteLock 能提供比独占锁更高的并发性。而对于只读的数据结构，其中包含的不变性可以完全不需要考虑加锁操作。

ReadWriteLock(读写锁):

写写/读写需要“互斥”

读读不需要互斥

/*
 * 1. ReadWriteLock : 读写锁
 * 
 * 写写/读写 需要“互斥”
 * 读读 不需要互斥
 * 
 */
public class TestReadWriteLock {

    public static void main(String[] args) {
        ReadWriteLockDemo rw = new ReadWriteLockDemo();
        
        new Thread(new Runnable() {
            
            @Override
            public void run() {
                rw.set((int)(Math.random() * 101));
            }
        }, "Write:").start();
        
        
        for (int i = 0; i < 100; i++) {
            new Thread(new Runnable() {
                
                @Override
                public void run() {
                    rw.get();
                }
            }).start();
        }
    }
    
}

class ReadWriteLockDemo{
    
    private int number = 0;
    
    private ReadWriteLock lock = new ReentrantReadWriteLock();
    
    //读
    public void get(){
        lock.readLock().lock(); //上锁
        
        try{
            System.out.println(Thread.currentThread().getName() + " : " + number);
        }finally{
            lock.readLock().unlock(); //释放锁
        }
    }
    
    //写
    public void set(int number){
        lock.writeLock().lock();
        
        try{
            System.out.println(Thread.currentThread().getName());
            this.number = number;
        }finally{
            lock.writeLock().unlock();
        }
    }
}

线程八锁

一个对象里面如果有多个synchronized方法，某一个时刻内，只要一个线程去调用其中的一个synchronized方法了，其它的线程都只能等待，换句话说，某一个时刻内，只能有唯一一个线程去访问这些synchronized方法。

锁的是当前对象this，被锁定后，其它的线程都不能进入到当前对象的其它的synchronized方法

所有的非静态同步方法用的都是同一把锁----实例对象本身，也就是说如果一个实例对象的非静态同步方法获取锁后，该实例对象的其他非静态同步方法必须等待获取锁的方法释放锁后才能获取锁，可是别的实例对象的非静态同步方法因为跟该实例对象的非静态同步方法用的是不同的锁，所以无需等待该实例对象已获取锁的非静态同步方法释放锁就可以获取他们自己的锁。

所有的静态同步方法用的也是同一把锁——类对象本身，这两把锁是两个不同的对象，所以静态同步方法与非静态同步方法之间是不会有竞态条件的。但是一旦一个静态同步方法获取锁后，其他的静态同步方法都必须等待该方法释放锁后才能获取锁，而不管是同一个实例对象的静态同步方法之间，还是不同的实例对象的静态同步方法之间，只要它们同一个类的实例对象！

实例：报数

该实例包含一个NumberOff类，其中包含了sayOne和sayTwo两个简单的打印方法，在main方法中创建NumberOff变量，并创建两个线程去执行sayOne和sayTwo方法。

public class Thread8MonitorTest {
    public static void main(String[] args) {
        NumberOff numberOff = new NumberOff();
        new Thread(new Runnable() {
            @Override
            public void run() {
                numberOff.sayOne();
            }
        }).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                numberOff.sayTwo();
            }
        }).start();
    }
}
class NumberOff {

    public void sayOne(){
        System.out.println("one");
    }

    public void sayTwo(){
        System.out.println("two");
    }
}

one
two

1、两个普通同步方法

将两个普通方法改为同步方法。

public class Thread8MonitorTest {
    public static void main(String[] args) {
        NumberOff numberOff = new NumberOff();
        new Thread(new Runnable() {
            @Override
            public void run() {
                numberOff.sayOne();
            }
        }).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                numberOff.sayTwo();
            }
        }).start();
    }
}

class NumberOff {

    public synchronized void sayOne(){
        System.out.println("one");
    }

    public synchronized void sayTwo(){
        System.out.println("two");
    }
}

one
two

2、给`sayOne`添加`Thread.sleep()`

给sayOne方法中添加Thread.sleep()，延迟打印。

public class Thread8MonitorTest {
    public static void main(String[] args) {
        NumberOff numberOff = new NumberOff();
        new Thread(new Runnable() {
            @Override
            public void run() {
                numberOff.sayOne();
            }
        }).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                numberOff.sayTwo();
            }
        }).start();
    }
}

class NumberOff {

    public synchronized void sayOne(){
        try {
            Thread.sleep(200);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("one");
    }

    public synchronized void sayTwo(){
        System.out.println("two");
    }
}

one
two

我们发现，sayTwo并没有因为sayOne线程sleep了就先打印，而是等待sayOne执行完成了，才执行sayTwo。原因是一个对象中，同一时刻只能有一个线程执行synchronized方法，虽然sayOne线程sleep了，但是该线程没有结束，所以sayTwo线程无法执行，只有等待sayOne线程结束了才能执行。

3、添加普通方法`sayThree`

public class Thread8MonitorTest {
    public static void main(String[] args) {
        NumberOff numberOff = new NumberOff();
        new Thread(new Runnable() {
            @Override
            public void run() {
                numberOff.sayOne();
            }
        }).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                numberOff.sayTwo();
            }
        }).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                numberOff.sayThree();
            }
        }).start();
    }
}

class NumberOff {

    public synchronized void sayOne(){
        try {
            Thread.sleep(200);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("one");
    }

    public synchronized void sayTwo(){
        System.out.println("two");
    }

    public void sayThree(){
        System.out.println("three");
    }
}

three
one
two

因为sayThree是一个普通的方法，所以不受同步和锁的干涉，所以sayThree先执行了。

4、两个同步方法，两个`NumberOff`对象

public class Thread8MonitorTest {
    public static void main(String[] args) {
        NumberOff numberOff = new NumberOff();
        NumberOff numberOff2 = new NumberOff();
        new Thread(new Runnable() {
            @Override
            public void run() {
                numberOff.sayOne();
            }
        }).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                numberOff2.sayTwo();
            }
        }).start();
    }
}

class NumberOff {

    public synchronized void sayOne(){
        try {
            Thread.sleep(200);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("one");
    }

    public synchronized void sayTwo(){
        System.out.println("two");
    } 
}

two
one

所有的非静态同步方法用的都是同一把锁----实例对象本身，以上实例中因为实例不同，所以sayTwo没有受到numberOff的sayOne方法的制约。

5、修改`sayOne`为静态同步方法

public class Thread8MonitorTest {
    public static void main(String[] args) {
        NumberOff numberOff = new NumberOff();
        new Thread(new Runnable() {
            @Override
            public void run() {
                NumberOff.sayOne();
            }
        }).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                numberOff.sayTwo();
            }
        }).start();
    }
}

class NumberOff {

    public static synchronized void sayOne(){
        try {
            Thread.sleep(200);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("one");
    }

    public synchronized void sayTwo(){
        System.out.println("two");
    }
}

two
one

静态同步方法用的锁是类对象本身，非静态同步方法用的是实例对象本身。因为锁的不同，所以sayOne没有制约sayTwo方法。

6、修改两个方法均为静态方法

public class Thread8MonitorTest {
    public static void main(String[] args) {  
        new Thread(new Runnable() {
            @Override
            public void run() {
                NumberOff.sayOne();
            }
        }).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                NumberOff.sayTwo();
            }
        }).start();
    }
}

class NumberOff {

    public static synchronized void sayOne(){
        try {
            Thread.sleep(200);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("one");
    }

    public static synchronized void sayTwo(){
        System.out.println("two");
    }
}

one
two

所有的静态同步方法用的是同一把锁——类对象本身，所以sayTwo受到了sayOne的制约。

7、一个静态同步方法，一个非静态同步方法，两个 Number 对象?

public class Thread8MonitorTest {
    public static void main(String[] args) {
        NumberOff numberOff = new NumberOff();
        NumberOff numberOff2 = new NumberOff();
        new Thread(new Runnable() {
            @Override
            public void run() {
                numberOff.sayOne();
            }
        }).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                numberOff2.sayTwo();
            }
        }).start();
    }
}

class NumberOff {

    public static synchronized void sayOne(){
        try {
            Thread.sleep(200);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("one");
    }

    public synchronized void sayTwo(){
        System.out.println("two");
    }
}

two
one

sayOne是一个静态同步方法，sayTwo是一个普通同步方法；以上实例中，执行sayOne的锁是NumberOff类，执行sayTwo的锁是numberOff2实例本身，所以sayTwo方法没有受到sayOne的制约。

8、两个静态同步方法，两个 Number 对象?

public class Thread8MonitorTest {
    public static void main(String[] args) {
        NumberOff numberOff = new NumberOff();
        NumberOff numberOff2 = new NumberOff();
        new Thread(new Runnable() {
            @Override
            public void run() {
                numberOff.sayOne();
            }
        }).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                numberOff2.sayTwo();
            }
        }).start();
    }
}

class NumberOff {

    public static synchronized void sayOne(){
        try {
            Thread.sleep(200);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("one");
    }

    public static synchronized void sayTwo(){
        System.out.println("two");
    }
}

one
two

因为两个方法均是静态同步方法，所以他们的锁是NumberOff类本身，所以无论哪个实例执行都是使用的同一个锁，所以有制约关系。

总结

线程八锁的关键：

①非静态方法的锁默认为调用实例本身, 静态方法的锁为对应的 Class 实例

②某一个时刻内，只能有一个线程持有锁，无论几个方法。

线程池

提供了一个线程队列，队列中保存着所有等待状态的线程。避免了创建与销毁额外开销，提高了响应的速度。

第四种获取线程的方法：线程池，一个 ExecutorService，它使用可能的几个池线程之一执行每个提交的任务，通常使用 Executors 工厂方法配置。

线程池可以解决两个不同问题：由于减少了每个任务调用的开销，它们通常可以在执行大量异步任务时提供增强的性能，并且还可以提供绑定和管理资源（包括执行任务集时使用的线程）的方法。每个 ThreadPoolExecutor 还维护着一些基本的统计数据，如完成的任务数。

为了便于跨大量上下文使用，此类提供了很多可调整的参数和扩展钩子 (hook)。但是，强烈建议程序员使用较为方便的 Executors 工厂方法：

Executors.newCachedThreadPool()（无界线程池，可以进行自动线程回收）
Executors.newFixedThreadPool(int)（固定大小线程池）
Executors.newSingleThreadExecutor()（单个后台线程）

它们均为大多数使用场景预定义了设置。

体系结构

java.util.concurrent.Executor : 负责线程的使用与调度的根接口
ExecutorService 子接口: 线程池的主要接口
- ThreadPoolExecutor 线程池的实现类
- ScheduledExecutorService 子接口：负责线程的调度
  - ScheduledThreadPoolExecutor ：继承 ThreadPoolExecutor，实现 ScheduledExecutorService

工具类

ExecutorService newFixedThreadPool() : 创建固定大小的线程池
ExecutorService newCachedThreadPool() : 缓存线程池，线程池的数量不固定，可以根据需求自动的更改数量。
ExecutorService newSingleThreadExecutor() : 创建单个线程池。线程池中只有一个线程
ScheduledExecutorService newScheduledThreadPool() : 创建固定大小的线程，可以延迟或定时的执行任务。

实例：使用线程池

使用Runnable方式

public class ThreadPoolTest {
    public static void main(String[] args) {
        /**
         * 1、创建线程池
         */
        ExecutorService pool = Executors.newFixedThreadPool(5);
        ThreadRunTest threadRunTest = new ThreadRunTest();

        /**
         * 2、为线程池中的线程分配任务
         * 这里分配了20个任务给线程池
         */
        for (int i = 0; i < 20; i++) {
            pool.submit(threadRunTest);
        }

        /**
         * 3.等所有线程运行完了再关闭线程池
         */
        pool.shutdown();
    }
}

class ThreadRunTest implements Runnable{

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+ " is run ");
    }
}

使用callable方式

public class ThreadPoolTest {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        /**
         * 1、创建线程池
         */
        ExecutorService pool = Executors.newFixedThreadPool(5);
        ThreadRunTest threadRunTest = new ThreadRunTest();

        /**
         * 2、为线程池中的线程分配任务
         */
        for (int i = 0; i < 10; i++) {
            Future<Integer> result = pool.submit(new Callable<Integer>() {
                @Override
                public Integer call() throws Exception {
                    int sum = 0;
                    for (int i = 1; i <= 100; i++) {
                        sum += i;
                    }
                    return sum;
                }
            });
            System.out.println("第"+ (i+1) +"次运行结果："+result.get());
        } 

        /**
         * 3.等所有线程运行完了再关闭线程池
         */
        pool.shutdown();
    }
}

实例：线程调度

ScheduledExecutorService:一个 ExecutorService，可安排在给定的延迟后运行或定期执行的命令。

public class TestScheduledThreadPool {

    public static void main(String[] args) throws Exception {
    // 1、创建可调度线程池
        ScheduledExecutorService pool = Executors.newScheduledThreadPool(5);
        
    // 2、分配任务和设置调度
        for (int i = 0; i < 5; i++) {
            Future<Integer> result = pool.schedule(new Callable<Integer>(){

                @Override
                public Integer call() throws Exception {
                    int num = new Random().nextInt(100);//生成随机数
                    System.out.println(Thread.currentThread().getName() + " : " + num);
                    return num;
                }
                
            }, 1, TimeUnit.SECONDS); // 1秒之后执行
            System.out.println(result.get());
        }
        // 3、关闭线程池
        pool.shutdown();
    } 
}

JUC学习笔记三

JUC学习笔记三

用于解决多线程同步问题的方式

隐式锁（`synchronized`）

显式锁(`JDK 1.5 以后`)

同步锁实例：卖票

生产者消费者问题

实例

等待唤醒机制

虚假唤醒

使用同步锁

Condition 控制线程通信

线程按序交替

读写锁

线程八锁

实例：报数

1、两个普通同步方法

2、给`sayOne`添加`Thread.sleep()`

3、添加普通方法`sayThree`

4、两个同步方法，两个`NumberOff`对象

5、修改`sayOne`为静态同步方法

6、修改两个方法均为静态方法

7、一个静态同步方法，一个非静态同步方法，两个 Number 对象?

8、两个静态同步方法，两个 Number 对象?

总结

线程池

体系结构

工具类

实例：使用线程池

实例：线程调度

相关文章

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读

JUC学习笔记三

JUC学习笔记三

用于解决多线程同步问题的方式

隐式锁（synchronized）

显式锁(JDK 1.5 以后)

同步锁实例：卖票

生产者消费者问题

实例

等待唤醒机制

虚假唤醒

使用同步锁

Condition 控制线程通信

线程按序交替

读写锁

线程八锁

实例：报数

1、两个普通同步方法

2、给sayOne添加Thread.sleep()

3、添加普通方法sayThree

4、两个同步方法，两个NumberOff对象

5、修改sayOne为静态同步方法

6、修改两个方法均为静态方法

7、一个静态同步方法，一个非静态同步方法，两个 Number 对象?

8、两个静态同步方法，两个 Number 对象?

总结

线程池

体系结构

工具类

实例：使用线程池

实例：线程调度

相关文章

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读

隐式锁（`synchronized`）

显式锁(`JDK 1.5 以后`)

2、给`sayOne`添加`Thread.sleep()`

3、添加普通方法`sayThree`

4、两个同步方法，两个`NumberOff`对象

5、修改`sayOne`为静态同步方法