Java JUC

最新推荐文章于 2024-05-06 10:37:06 发布
最新推荐文章于 2024-05-06 10:37:06 发布
阅读量102 收藏
点赞数
分类专栏： java 全栈技术 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lovewangyihui/article/details/119324958
版权

一、基本概念

什么是juc**

Java 5.0 提供了java.util.concurrent（简称JUC ）包

进程

是执行的一个应用，比如qq启动，就启动了一个进程

线程

一个进程执行中的每个任务，比如QQ同时接受多个人的消息，接受消息就是线程

关系

一个进程包含一个或多个线程

java默认有两个线程 main和GC

并发

多个线程同时操作一个资源

CPU一核，模拟多条线程

并行

多个人同时行走

CPU多核，多个线程可以同时执行

并发编程的本质：充分利用CPU资源

二、回顾多线程

线程相关类位于java long 包

1、线程创建

继承于Thread类
#继承Thread类，重写run()方法，调用start()开启线程
public class Test01 extends Thread {
    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            System.out.println("线程" + i);
        }
    }

    public static void main(String[] args) {
        Test01 t = new Test01();
        t.start();
        for (int i = 0; i < 20; i++) {
            System.out.println("主线程" + i);
        }
    }
}

打印结果线程与主线程交替，由此可见线程的执行由cpu调度，与代码顺序无关

实现Runnable接口
public class Test02 implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            System.out.println("线程" + i);
        }
    }

    public static void main(String[] args) {
        //实现类实例
        Test02 t = new Test02();
        //代理类实例
        Thread thread = new Thread(t);
        thread.start();
        for (int i = 0; i < 20; i++) {
            System.out.println("主线程" + i);
        }
    }
}

这里运用了静态代理

实现Callable接口

步骤：

实现Calleble接口

重写call()方法

创建执行服务

ExecutorService是一个线程池接口

ExecutorService ser = Executors.newFixedThreadPool(线程数);

提交执行

Future<返回值类型> r = ser.submit(线程名)；

获取结果

类型 res=r.get();

关闭服务

ser.shutdownNow();

public class Test03 implements Callable<String> {
    private boolean flag = false;
    @Override
    public String call() throws Exception {
        synchronized (this) {
            if(this.flag == false) {
                this.flag = true ;
                return Thread.currentThread().getName()+"抢答成功";
            }else {
                return Thread.currentThread().getName()+"抢答失败";
            }
        }
    }

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        Test03 mt = new Test03();
        FutureTask<String> taskA = new FutureTask<String>(mt);
        FutureTask<String> taskB = new FutureTask<String>(mt);
        FutureTask<String> taskC = new FutureTask<String>(mt);
        new Thread(taskA,"竞赛者A").start();
        new Thread(taskB,"竞赛者B").start();
        new Thread(taskC,"竞赛者C").start();
        System.out.println(taskA.get());
        System.out.println(taskB.get());
        System.out.println(taskC.get());
    }
}

2、初始并发问题

多个线程操作同一个对象

买票问题，多个人可能买到统一张票

package juc;

public class KictetThread extends Thread {
    //票数
    private int ticketNums = 10;

    @Override
    public void run() {
        while(true){
            if(ticketNums<=0){
                break;
            }

            //模拟延时
            try {
                Thread.sleep(200);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            System.out.println(Thread.currentThread().getName()+"-->拿到了第"+ticketNums-- +"票");
        }

    }

    public static void main(String[] args) {
        KictetThread ticket = new KictetThread ();

        new Thread(ticket,"小明").start();
        new Thread(ticket,"老师").start();
        new Thread(ticket,"黄牛").start();
    }

}

运行结果

老师-->拿到了第9票
黄牛-->拿到了第8票
小明-->拿到了第10票
黄牛-->拿到了第7票
老师-->拿到了第6票
小明-->拿到了第5票
老师-->拿到了第3票
黄牛-->拿到了第4票
小明-->拿到了第4票
小明-->拿到了第2票
黄牛-->拿到了第1票
老师-->拿到了第2票

3、Lambda表达式

函数式编程

一个接口只有一个抽象方法可以用

test1

public interface Test04 {
    void f();
}

public class test {
    public static void main(String[] args) {
        Test04 test04 = () ->{
            System.out.println("123");
        };
        test04.f();
    }
}

test2

public interface Test05 {
    String f();
}

Test05 test05 = () ->{return "函数式编程";};
System.out.println(test05.f());

4、线程状态

1. 新建状态(New): 线程对象被创建后，就进入了新建状态。例如，Thread thread = new Thread()。

2. 就绪状态(Runnable): 也被称为“可执行状态”。线程对象被创建后，其它线程调用了该对象的start()方法，从而来启动该线程。例如，thread.start()。处于就绪状态的线程，随时可能被CPU调度执行。

3. 运行状态(Running): 线程获取CPU权限进行执行。需要注意的是，线程只能从就绪状态进入到运行状态。

4. 阻塞状态(Blocked): 阻塞状态是线程因为某种原因放弃CPU使用权，暂时停止运行。直到线程进入就绪状态，才有机会转到运行状态。阻塞的情况分三种：

  • (01) 等待阻塞 – 通过调用线程的wait()方法，让线程等待某工作的完成。
  • (02) 同步阻塞 – 线程在获取synchronized同步锁失败(因为锁被其它线程所占用)，它会进入同步阻塞状态。
  • (03) 其他阻塞 – 通过调用线程的sleep()或join()或发出了I/O请求时，线程会进入到阻塞状态。当sleep()状态超时、join()等待线程终止或者超时、或者I/O处理完毕时，线程重新转入就绪状态。

5. 死亡状态(Dead): 线程执行完了或者因异常退出了run()方法，该线程结束生命周期。

线程状态图

img

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-puC7iEcz-1627886858499)(C:\Users\wyh\Desktop\截图\线程状态.PNG)]

t.getState()  //获取线程状态

5、线程常用方法

sleep() – 线程休眠
  • sleep（时间）指定当前线程阻塞的毫秒数；
  • sleep 存在异常 InterruptedException；
  • sleep 时间达到后线程进入就绪状态；
  • sleep 可以模拟网络延时，倒计时等；
  • sleep 每一个对象都有一个锁，sleep 不会释放锁；
public class Test06  {

    public void run() throws InterruptedException {
        for (int i = 10; i > 0; i--) {
            sleep(1000);
            System.out.println("倒计时："+i);
        }
    }

    public static void main(String[] args) throws InterruptedException {
        Test06 t = new Test06();
        t.run();
    }
}

public class Test06 implements Runnable {
    @Override
    public void run() {
        for (int i = 10; i > 0; i--) {
            try {
                sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            System.out.println("倒计时："+i);
        }
    }

    public static void main(String[] args) {
        Test06 t = new Test06();
        Thread thread = new Thread(t);
        thread.start();
    }
}
yield() – 线程礼让
  • 礼让线程，让当前正在执行的线程暂停，但不阻塞；
  • 将线程从运行状态转为就绪状态；
  • 让 CPU 从新调度，有可能还是调度该礼让线程。
 @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"开启了线程");
        Thread.yield();
        System.out.println(Thread.currentThread().getName()+"结束了线程");
    }

    public static void main(String[] args) {

        TestYield testYield = new TestYield();
        Thread threadA = new Thread(testYield,"threadA");
        Thread threadB = new Thread(testYield,"threadB");

        threadA.start();
        threadB.start();
    }
Join() – 线程合并（插队）
public class TestJoin implements Runnable{

    @Override
    public void run() {
        for (int i = 0; i < 1000; i++) {
            System.out.println("Thread : "+i);
        }
    }

    public static void main(String[] args) throws InterruptedException {
        TestJoin join = new TestJoin();
        Thread thread = new Thread(join);
        thread.start();

        for (int i = 0; i < 200; i++) {
            if (i==100){
                thread.join();                 //插入主线程
            }
            System.out.println("main :"+i);
        }
    }
}

6、停止线程

stop(),destory()都已经过时

stop()被抛弃的原因 1.虽然停止了线程，但是线程并未执行完，会导致没有释放资源

interrupt()中断线程

interrupt() 方法只是改变中断状态而已，它不会中断一个正在运行的线程。如果线程被Object.wait, Thread.join和Thread.sleep三种方法之一阻塞，此时调用该线程的interrupt()方法，那么该线程将抛出一个 InterruptedException中断异常

  1. sleep() &interrupt()

线程A正在使用sleep()暂停着: Thread.sleep(100000)，如果要取消它的等待状态,可以在正在执行的线程里(比如这里是B)调用a.interrupt()［a是线程A对应到的Thread实例］，令线程A放弃睡眠操作。即，在线程B中执行a.interrupt()，处于阻塞中的线程a将放弃睡眠操作。

当在sleep中时线程被调用interrupt()时，就马上会放弃暂停的状态并抛出InterruptedException。抛出异常的,是A线程。

代码

public class Test01 extends Thread {
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            try {
                sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("线程" + i);
        }
    }

    public static void main(String[] args) {
        Test01 t = new Test01();
        t.start();
        for (int i = 0; i < 100; i++) {
            if(i == 50){
                t.interrupt();        //中断线程
                return;
            }
            System.out.println("主线程" + i);
        }
    }
}

结果

java.lang.InterruptedException: sleep interrupted
	at java.lang.Thread.sleep(Native Method)
	at juc.Test01.run(Test01.java:8)
  1. wait() &interrupt()

线程A调用了wait()进入了等待状态，也可以用interrupt()取消。不过这时候要注意锁定的问题。线程在进入等待区,会把锁定解除,当对等待中的线程调用interrupt()时，会先重新获取锁定，再抛出异常。在获取锁定之前，是无法抛出异常的。

  1. join() &interrupt()

当线程以join()等待其他线程结束时，当它被调用interrupt()，它与sleep()时一样，会马上跳到catch块里。

合理停止线程的方法是设置 一个标志位进行终止变量 ， 当 flag == false,则终止线程运行。

代码

public class ThreadStop implements Runnable{

    private boolean flag = true;

    @Override
    public void run() {
        int i = 0;
        while (flag){
            System.out.println("--- ThreadStop  ---"+i);
            i++;
        }
    }
    public void stop(){
        this.flag = false;
    }

    public static void main(String[] args) {

        ThreadStop threadStop = new ThreadStop();
        Thread thread = new Thread(threadStop);
        thread.start();


        for (int i = 0; i < 1000; i++) {
            if (i==900){
                threadStop.stop();
            }
            System.out.println("--- main ---"+i);
        }
    }

}

7、唤起线程

1.wait()的作用是让当前线程进入等待状态，同时，wait()也会让当前线程释放它所持有的锁。“直到其他线程调用此对象的 notify() 方法或 notifyAll() 方法”，当前线程被唤醒(进入“就绪状态”)

2.notify()和notifyAll()的作用，则是唤醒当前对象上的等待线程；notify()是唤醒单个线程，而notifyAll()是唤醒所有的线程。

3.wait(long timeout)让当前线程处于“等待(阻塞)状态”，“直到其他线程调用此对象的notify()方法或 notifyAll() 方法，或者超过指定的时间量”，当前线程被唤醒(进入“就绪状态”)。

注意

wait和 notify必须配合synchronized使用，wait方法释放锁，notify方法不释放锁

public class Test08 {
    public static void main(String[] args) {
        // 定义一个锁对象
        Object lock = new Object();
        List<String>  list = new ArrayList<>();
        // 实现线程A
        Thread threadA = new Thread(() -> {
            synchronized (lock) {
                for (int i = 1; i <= 10; i++) {
                    list.add("abc");
                    System.out.println("线程A向list中添加一个元素，此时list中的元素个数为：" + list.size());
                    try {
                        Thread.sleep(500);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    if (list.size() == 5) {
                        lock.notify();// 唤醒B线程
                    }
                }
            }
        });
        // 实现线程B
        Thread threadB = new Thread(() -> {
            while (true) {
                synchronized (lock) {
                    if (list.size() != 5) {
                        try {
                            lock.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                    System.out.println("线程B收到通知，开始执行自己的业务...");
                }
            }
        });
        //　需要先启动线程B
        threadB.start();
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        // 再启动线程A
        threadA.start();
    }
}

8、线程优先级

Java 提供一个线程调度器来监控程序中启动后进入就绪状态的所有线程，线程调度器按照优先级决定应该调度哪个线程来执行。
线程的优先级用数字表示，范围从1~10.
Thread.MIN_PRIORITY=1;
Thread.MAX_PRIORITY=10;
Thread.NORM_PRIORITY=5;
使用以下方式改变或获取优先级
getPriority().setPriority(int xxx)；

9、守护线程

线程分为用户线程和守护线程

用户线程

平时用到的普通线程均是用户线程，当在Java程序中创建一个线程，它就被称为用户线程

守护线程

为其它线程提供服务； 比如垃圾回收线程，就是最典型的守护线程。

虚拟机必须确保用户线程执行完毕

虚拟机不用等待守护线程执行完毕

如，后台记录操作日志，监控内存垃圾回收等待…

10、线程同步问题

一个对象被多个线程操作

买票问题，多个人可能同时买到一张票

取钱问题；总余额500万，AB同时取；A取了300万，余额没有减少，B取了500万…

解决办法 synchronized 方法和 synchronized 块.

synchronized 相当于一个门的把手，当一个人进去之后，就锁上，当这个人结束出来以后，门把手打开。

代码

public class Test07 implements Runnable{
    //票数
    private int ticketNums = 20;

    @Override
    public void run() {
        while(true){
            if(ticketNums == 0){
                break;
            }

            //模拟延时
            try {
                Thread.sleep(200);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            System.out.println(Thread.currentThread().getName()+"-->拿到了第"+ticketNums-- +"票");
        }

    }

    public static void main(String[] args) {
        Test07 ticket = new Test07 ();

        new Thread(ticket,"小明").start();
        new Thread(ticket,"老师").start();
        new Thread(ticket,"黄牛").start();
    }

}

结果

老师–>拿到了第7票
小明–>拿到了第7票

解决：

synchronized 块 和synchronized 修饰方法

public class Test07 implements Runnable{
    //票数
    private int ticketNums = 20;

    @Override
    public void run() {
        while(true){
            synchronized (this) {
                if(ticketNums == 0){
                    break;
                }

                //模拟延时
                try {
                    Thread.sleep(200);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

                System.out.println(Thread.currentThread().getName()+"-->拿到了第"+ticketNums-- +"票");
            };

        }

    }

    public static void main(String[] args) {
        Test07 ticket = new Test07 ();

        new Thread(ticket,"小明").start();
        new Thread(ticket,"老师").start();
        new Thread(ticket,"黄牛").start();
    }

}


public class Test07 implements Runnable{
    //票数
    private int ticketNums = 20;

    @Override
    public void run() {
        while(true){
            buy();
        }

    }

    private synchronized void buy() {
        if(ticketNums == 0){
            return;
        }

        //模拟延时
        try {
            Thread.sleep(200);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println(Thread.currentThread().getName()+"-->拿到了第"+ticketNums-- +"票");
    }

    public static void main(String[] args) {
        Test07 ticket = new Test07 ();

        new Thread(ticket,"小明").start();
        new Thread(ticket,"老师").start();
        new Thread(ticket,"黄牛").start();
    }

}

运行结果

小明-->拿到了第20票
小明-->拿到了第19票
小明-->拿到了第18票
小明-->拿到了第17票
小明-->拿到了第16票
小明-->拿到了第15票
小明-->拿到了第14票
小明-->拿到了第13票
小明-->拿到了第12票
小明-->拿到了第11票
小明-->拿到了第10票
小明-->拿到了第9票
小明-->拿到了第8票
小明-->拿到了第7票
小明-->拿到了第6票
小明-->拿到了第5票
小明-->拿到了第4票
小明-->拿到了第3票
小明-->拿到了第2票
小明-->拿到了第1票

当小明买票，就只能等他买票结束，其他人才能买票，相当于排队

11、死锁

多个线程各自占有一些共享资源，并且互相等待其他线程占有的资源才能运行，而导致两个或者多个线程都在等待对方释放资源，都停止执行的情形。某一个同步块同时拥“两个以上对象的锁”时，就可能会发生“死锁”的问题。

简单理解： 两个线程互相占有对方需要的资源而不释放，便形成了死锁。

产生死锁的四个必要条件：

互斥条件：一个资源每次只能被一个进程使用。
请求与保持条件：一个进程因请求资源而阻塞时，对已获得的资源保持不放。
不剥夺条件：进程已获得的资源，在未使用完之前，不能强行剥夺。
循环等待条件：若干进程之间形成一种头尾相接的循环等待资源关系。

上述四个条件，只要破坏其任意一个就可避免死锁的发生。

**例子：**创建两个字符串a和b，再创建两个线程A和B，让每个线程都用synchronized锁住字符串（A先锁a，再去锁b；B先锁b，再锁a），如果A锁住a，B锁住b，A就没办法锁住b，B也没办法锁住a，这时就陷入了死锁。

public class DeadLock {
    public static String obj1 = "obj1";
    public static String obj2 = "obj2";
    public static void main(String[] args){
        Thread a = new Thread(new Lock1());
        Thread b = new Thread(new Lock2());
        a.start();
        b.start();
    }    
}
class Lock1 implements Runnable{
    @Override
    public void run(){
        try{
            System.out.println("Lock1 running");
            while(true){
                synchronized(DeadLock.obj1){
                    System.out.println("Lock1 lock obj1");
                    Thread.sleep(3000);//获取obj1后先等一会儿，让Lock2有足够的时间锁住obj2
                    synchronized(DeadLock.obj2){
                        System.out.println("Lock1 lock obj2");
                    }
                }
            }
        }catch(Exception e){
            e.printStackTrace();
        }
    }
}
class Lock2 implements Runnable{
    @Override
    public void run(){
        try{
            System.out.println("Lock2 running");
            while(true){
                synchronized(DeadLock.obj2){
                    System.out.println("Lock2 lock obj2");
                    Thread.sleep(3000);
                    synchronized(DeadLock.obj1){
                        System.out.println("Lock2 lock obj1");
                    }
                }
            }
        }catch(Exception e){
            e.printStackTrace();
        }
    }
}

12、Lock锁

从 JDK 5.0 开始，Java 提供了更强大的线程同步机制——通过显示定义同步锁对象来实现同步。同步锁使用 Lock对象充当
java.util.concurrent.locks.Lock 接口是控制多个线程对共享资源进行访问的工具。锁提供了对共享资源的独占访问，每次只能有一个线程对 Lock 对象加锁，线程开始访问共享资源之前应先获得 Lock 对象
ReentrantLock 类实现了 Lock ，它拥有与 synchronized 相同的并发性和内存语义，在实现线程安全的控制中，比较常用的是 ReentrantLock ，可以显示加锁、释放锁。

synchronized 与 Lock 的对比

Lock 是显示锁（手动开启和关闭），synchronized 是隐式锁，出了作用域自动释放
Lock 只有代码加锁，synchronized 有代码块锁和方法锁
使用 Lock 锁，JVM 将花费较少的时间来调度线程，性能更好。并具有更好的扩展性（提供更多的子类）
Lock > 同步代码块（已经进入了方法体，分配了相应资源）>同步方法（在方法体之外）

代码

public class Test07 implements Runnable{
    //票数
    private int ticketNums = 20;
    //声明一个锁
    private ReentrantLock lock = new ReentrantLock();
    @Override
    public void run() {
        while(true){
            try{
               lock.lock();
               if(ticketNums == 0){
                    break;
               }
               try {
                    Thread.sleep(200);
               } catch (InterruptedException e) {
                    e.printStackTrace();
               }

            }finally {
                lock.unlock();
            }
            System.out.println(Thread.currentThread().getName()+"-->拿到了第"+ticketNums-- +"票");
        }

    }

    public static void main(String[] args) {
        Test07 ticket = new Test07 ();

        new Thread(ticket,"小明").start();
        new Thread(ticket,"老师").start();
        new Thread(ticket,"黄牛").start();
    }

}

13、线程之间的通信

wait/notify 机制

一个线程调用 Object 的 wait() 方法，使其线程被阻塞；另一线程调用 Object 的 notify()/notifyAll() 方法，wait() 阻塞的线程继续执行。

所以线程之间的通信可以通过wait/notify 机制。

应用场景：生产者和消费者问题

假设仓库中只能存放一件产品，生产者将生产出来的产品放入仓库，消费者将仓库中产品取走消费。

如果仓库中没有产品，则将生产者将产品放入仓库，否则停止生产并等待，直到仓库中的产品被消费者取走为止。

如果仓库中放有产品，则消费者可以将产品取走消费，否则停止消费，直到仓库中再次放入产品为止。

在这里插入图片描述

这是一个线程同步问题，生产者和消费者共享同一个资源，并且生产者和消费者之间相互依赖，互为条件。

对于生产者，没有生产产品之前，要通知消费者等待.而生产了产品之后，又需要马上通知消费者消费
对于消费者，在消费之后，要通知生产者已经结束消费，需要生产新的产品以供消费.
在生产者消费者问题中，仅有synchronized是不够的
synchronized 可阻止并发更新同一个共享资源，实现了同步
synchronized 不能用来实现不同线程之间的消息传递（通信）

5.1 解决线程之间通信问题的几个方法

在这里插入图片描述

注意：均是 Object 类的方法，都只能在同步方法或者同步代码块中使用，否则会抛出异常 llegalMonitorStateException

管乘法
  • 生产者：负责生产数据的模块（可能是方法，对象，线程，进程）；
  • 消费者：负责处理数据的模块（可能是方法，对象，线程，进程）
  • 缓冲区：消费者不能直接使用生产者的数据，他们之间有个缓冲区
public class Test08 {
    public static void main(String[] args) {
        SynContainer container = new SynContainer();
        new Productor(container).start();
        new Consumer(container).start();
    }

}

// 生产者
class Productor extends Thread{
    SynContainer container;
    public Productor(SynContainer container){
        this.container = container;
    }

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println("生产了"+i+"只鸡");
            container.push(new Chicken(i));
        }
    }
}


class SynContainer{
    //    需要一个容器的大小
    Chicken[] chickens = new Chicken[10];
    //    容器计数器
    int count = 0;


    //    生产者放入产品
    public synchronized void push(Chicken chicken){
//        如果容器满了,就需要等待消费者消费
        if (count == chickens.length){
//            通知消费者消费,生产等待
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        chickens[count] = chicken;
        count++;
        this.notifyAll();
    }


    //    消费者消费产品
    public synchronized Chicken pop(){
//        判断能否消费
        if(count==0){
//            等待生产者生产,消费者等待
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
//        如果可以消费
        count--;
        Chicken chicken = chickens[count];
//        可以通知消费了
        this.notifyAll();

        return chicken;
    }
}



class Consumer extends Thread{
    SynContainer container;
    public Consumer(SynContainer container){
        this.container = container;
    }

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println("消费了-->"+container.pop().id+"只鸡");
        }
    }
}



// 产品
class Chicken{
    int id;  //产品编号
    public Chicken(int id){
        this.id = id;
    }
}
信号灯法
public class TestPC2 {
    public static void main(String[] args) {
        TV tv = new TV();
        new Player(tv).start();
        new Wathcher(tv).start();
    }
}

//生产者--演员
class Player extends Thread{
    TV tv;
    public Player(TV tv){
        this.tv = tv;
    }

    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            if(i%2==0){
                this.tv.play("快乐大本营");
            }else{
                this.tv.play("天天向上");
            }
        }
    }
}

//观众
class Wathcher extends Thread{
    TV tv;
    public Wathcher(TV tv){
        this.tv = tv;
    }

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

//产品--节目
class TV{
//    演员表演,观众等待  T
//    观众观看,演员等待  F
    String voice;  // 表演节目
    boolean flag = true;

//    表演
    public synchronized void play(String voice){
        if(!flag){
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println("演员表演了: "+voice);
//        通知观众观看
        this.notifyAll();// 通知唤醒
        this.voice = voice;
        this.flag = !flag;
    }

//    观看
    public synchronized void watch(){
        if (flag){
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println("观看了: "+voice);
//        通知演员表演
        this.notifyAll();
        this.flag = !this.flag;
    }
}

14、线程池的使用

线程池： 管理线程的池子。

管理线程，避免增加创建线程和销毁线程的资源损耗。因为线程其实也是一个对象，创建一个对象，需要经过类加载过程，销毁一个对象，需要走GC垃圾回收流程，都是需要资源开销的。

提高响应速度。 如果任务到达了，相对于从线程池拿线程，重新去创建一条线程执行，速度肯定慢很多。

重复利用。 线程用完，再放回池子，可以达到重复利用的效果，节省资源。

创建线程池的核心参数

corePoolSize： 线程池核心线程数最大值

maximumPoolSize： 线程池最大线程数大小

keepAliveTime： 线程池中非核心线程空闲的存活时间大小

unit： 线程空闲存活时间单位

workQueue： 存放任务的阻塞队列

threadFactory： 用于设置创建线程的工厂，可以给创建的线程设置有意义的名字，可方便排查问题。

handler： 线城池的饱和策略事件，主要有四种类型。

lovewangyihui
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java JUC包 思维导图总结1
03-25
自己学习过程对Java JUC包知识的总结，看完并理解基本能应付各种基本的问题点，墙裂推荐分享 博客跳转链接： https://blog.csdn.net/qq_35642036/article/details/82767070
Java多线程：Runnable实现龟兔赛跑
frozenpenguin的博客
07-10 1373
Java通过实现Runnable简单实现龟兔赛跑游戏。
Java——多线程总结
云祁QI
09-16 1057
并发与并行 并发：指两个或多个事件在同一个时间段内发生。 并行：指两个或多个事件在同一时刻发生（同时发生）。 在操作系统中，安装了多个程序，并发指的是在一段时间内宏观上有多个程序同时运行，这在单 CPU 系统中，每一时刻只能有一道程序执行，即微观上这些程序是分时的交替运行，只不过是给人的感觉是同时运行，那是因为分时交替运行的时间是非常短的。 而在多个 CPU 系统中，则这些可以并发执行的程序便...
Java练习题-龟兔赛跑
JAVA小章的博客
09-02 683
多线程龟兔赛跑问题，乌龟和兔子比赛跑200米的距离， 名叫兔子的线程每执行一次兔子就向前跑5米，每跑50米休息10毫秒， 名叫乌龟的线程每执行一次乌龟就向前跑1米，乌龟会一直跑不休息 用多线程实现求出最后的胜利者是谁 package com.itheima.test06; public class Race implements Runnable { //winner:只有一个胜利者 private static String winner; int lengthr = 200;
Java学习记录 Day22（线程）
赈川
06-04 293
Day 22 2019年6月2日。 这是我来到西部开源的第二十二天。 这一天，我学到了以下的知识。 线程简介 线程，是操作系统能够进行运算调度的最小单位。它被包含在进程之中，是进程中的实际运作单位。一条线程指的是进程中一个单一顺序的控制流，一个进程中可以并发多个线程，每条线程并行执行不同的任务。 在Java中，线程的执行如图所示： 说起线程，就必须要说到程序。程序是指令和数据的有序集合，其本身没...
[Java] SE 机考题：集合、IO、多线程（二）
Regino的博客
04-05 3495
本文介绍了 Java SE 的机考题的第二部分，有关集合、IO、多线程等内容，包含了若干选择题和 4 个编程题。。。
22 尚硅谷Java JUC线程高级视频
08-07
教程视频：在 Java 5.0 提供了 java.util.concurrent(简称JUC)包,在此包中增加了在并发编程中很常用的工具类, 用于定义类似于线程的自定义子系统,包括线程池,异步 IO 和轻量级任务框架;还提供了设计用于多线程上下文...
Java——JUC
12-29
用于定义类似于线程的自定义子系统,包括线程池,异步 IO 和轻量级任务框架;包含下载地址
juc aqs java
12-14
juc 的aqs介绍。
Java多线程和JUC.pdf
01-22
java多线程的一些知识与问题的总结
浅谈创建单线程的方式
Java开发者Peng博客
07-16 290
方式1：继承thread类 代码如下： package com.test; public class TestThread extends Thread{ @Override public void run() { //todo线程操作业务代码 } } 方式2：实现Runnable接口 package com.test; public class TestThread implements Runnable{ @Overri...
多线程，线程简介，线程的创建，静态代理，Lamda表达式
weixin_44823472的博客
07-12 112
多线程 线程简介 任务，进程，线程，多线程 多任务：在现实生活中同时做多件事，看起来是多个任务都在做，实际上我们的大脑在同一时间只做了一件事情 线程：线程，有时被称为轻量级进程(Lightweight Process，LWP），是程序执行流的最小单元。一个标准的线程由线程ID，当前指令指针(PC），寄存器集合和堆栈组成。另外，线程是进程中的一个实体，是被系统独立调度和分派的基本单位，线程自己不拥有...
JAVA多线程
qq_43349542的博客
07-11 109
//Thrad实现多线程 //创建线程方式一：继承Thrad类，重写run()方法，调用start开启线程 //总结：注意！！线程开启不一定立即执行，由CPU调度执行 public class TestThread1 extends Thread{ //run方法线程体 @Override public void run() { for (int i = 0; i < 200; i++) { System.out.println("我在...
Java学习总结--041龟兔赛跑
web116629的博客
06-15 486
//龟兔赛跑 public class Race implements Runnable{ //winner:只有一个胜利者 private static String winner; @Override public void run() { //赛道 for (int step = 1; step <= 101; step+...
Java多线程实现方式2：runnable接口、龟兔赛跑案例
yalu_123456的博客
06-06 1185
实现Runnable 定义MyRunnable类实现Runnable接口 实现run()方法，编写线程执行体 创建线程对象，调用start()方法启动线程 案例： package MyDemo; //创建线程方式2：实现runnable接口 //1.实现接口 //2.重写run方法 //3.创建runbale接口实现类的对象。 //启动线程。需要创建一个线程Thread对象 ， 然后把runb...
链表刷题集
yajunjiao的专栏
04-30 900
本文主要列举了一些刷的题，不多，有那么几道，也建议各位去建立自己的刷题集。积少成多。
《设计一款蓝牙热敏打印机》
最新发布
唐顺才的博客
05-06 171
安卓apk用java + kotlin编写、上位机用Qt编写。主控芯片用易兆威蓝牙ic，通讯接口：蓝牙、串口、usb。
【一步一步了解Java系列】：探索Java基本类型与C语言的区别
2302_81249757的博客
04-29 1216
​​喜欢的一句话： 常常会回顾努力的自己，所以要为自己的努力留下足迹。作者：小闭。
Nacos 配置中心实例分析实践
m0_73557631的博客
05-03 1014
​ 浏览器: http://localhost:5000/nacos/config/ip。先创建e-commerce-nacos-config-client5000 模块。​ 启动e-commerce-nacos-config-client5000。​ 启动Nacos Server。
java juc面试
10-06
Java JUC（Java Util Concurrent）是Java并发编程中的一个重要模块，提供了一系列的工具类和API，用于实现高效的并发编程。 Java JUC包括了以下几个核心组件： 1. 锁：Java提供了多种锁机制来实现并发编程，例如...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值