Java之多线程

最新推荐文章于 2024-05-19 21:34:53 发布
最新推荐文章于 2024-05-19 21:34:53 发布
阅读量119 收藏
点赞数 3
分类专栏： Java基础 文章标签： java 多线程 intellij idea
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_37530429/article/details/120059290
版权

目录

多线程

基本概念：程序、进程、线程

●程序（program）： 是为完成特定任务、用某种语言编写的一组指令的集合。即指一段静态的代码，静态对象。
●进程（process）： 是程序的一次执行过程，或是正在运行的一个程序。是一个动态的过程：有它自身的产生、存在和消亡的过程。——生命周期
♢如：运行中的QQ、微信等；
♢程序是静态的，进程是动态的；
♢打开我们的Windows任务管理器，就可以看到我们动态中的进程。
●线程（thread）： 进程可进一步细化为线程，是一个程序内部的一条执行路径。
进程与线程的关系如下图所示：
在这里插入图片描述
●单核CPU和多核CPU的理解
♢单核CPU，其实是一种假的多线程，因为在一个时间单元内，也只能执行一个线程的任务。例如：虽然有多车道，但是收费站只有一个工作人员在收费，只有收了费才能通过，那么CPU就好比收费人员。如果有某个人不想交钱， 那么收费人员可以把他“挂起”（晾着他，等他想通了，准备好了钱，再去收费）。但是因为CPU时间单元特别短，因此感觉不出来。
♢如果是多核的话，才能更好的发挥多线程的效率。（现在的服务器都是多核的）
♢ 一个Java应用程序java.exe，其实至少有三个线程： main()主线程， gc()垃圾回收线程，异常处理线程。当然如果发生异常，会影响主线程。
●并行与并发
♢并行： 多个CPU同时执行多个任务。比如：多个人同时做不同的事。
♢并发： 一个CPU(采用时间片)同时执行多个任务。比如：秒杀、多个人做同一件事。

●使用多线程的优点
①提高应用程序的响应。对图形化界面更有意义，可增强用户体验；
②提高计算机系统CPU的利用率；
③改善程序结构。将既长又复杂的进程分为多个线程，独立运行，利于理解和修改。

●那我们何时需要多线程？
①程序需要同时执行两个或多个任务；
②程序需要实现一些需要等待的任务时，如用户输入、文件读写操作、网络操作、搜索等；
③需要一些后台运行的程序时。

线程的创建和使用

（1）创建方式一：继承于Thread类

1.创建一个继承于Thread类的子类；
2.重写Thread类的run()；
3.创建Thread类的子类的对象；
4.通过此对象调用start()：①启动当前线程；②调用当前线程的run()。

package com.java.thread;
/**
 * @description:
 * 多线程的创建，方式一：继承于Thread类
 * @author: Fish_Vast
 * @Date: 2021/9/2
 * @version: 1.0
 */

//1.创建一个继承于Thread类的子类
class MyThread extends Thread{
    //2.重写Thread类的run()
    @Override
    public void run() {
        for (int i = 0; i <= 100; i++) {
            if(i % 2 == 0){
                System.out.println(currentThread().getName()+":"+i);
            }
        }
    }

}

public class ThreadTest {
    public static void main(String[] args) {
        //3.创建Thread类的子类的对象
        MyThread myThread = new MyThread();
        //4.通过此对象调用start()
        myThread.start();
    }
}

在这里插入图片描述

package com.java.thread;
/**
 * @description:
 * 1.创建两个线程，一个遍历0-100的偶数，另一个遍历0-100的奇数
 * 2.通过面向对象方法中的匿名子类实现1-100的遍历
 * @author: Fish_Vast
 * @Date: 2021/9/2
 * @version: 1.0
 */
class MyThread2 extends Thread{
    @Override
    public void run() {
        for (int i = 0; i <= 100; i++) {
            if(i % 2 == 0){
                System.out.println(currentThread().getName()+":"+i);
            }
        }
    }
}

class MyThread3 extends Thread{
    @Override
    public void run() {
        for (int i = 0; i <= 100; i++) {
            if(i % 2 != 0){
                System.out.println(currentThread().getName()+":"+i);
            }
        }
    }
}

public class ThreadTest2 {
    public static void main(String[] args) {
        MyThread2 myThread2 = new MyThread2();
        MyThread3 myThread3 = new MyThread3();
        //设置对应线程的名字
        myThread2.setName("线程二");
        myThread3.setName("线程三");
        myThread2.start();
        myThread3.start();
        //创建Thread类的匿名子类的方式
        new Thread(){
            @Override
            public void run() {
                //设置当前线程的名字
                currentThread().setName("线程一");
                for (int i = 1; i <= 100; i++) {
                    System.out.println(currentThread().getName()+":"+i);
                }
            }
        }.start();
    }
}

在这里插入图片描述

（2）创建方式二：实现Runnable接口

1.创建一个实现了Runnable接口的类；
2.实现类去实现Runnable中的抽象方法：run()；
3.创建实现类的对象；
4.将此对象作为参数传递到Thread类的构造器中，创建Thread类的对象；
5.通过Thread类的对象调用start()。

package com.java.thread;
/**
 * @description:
 * 多线程的创建，方式二：实现Runnable接口
 * @author: Fish_Vast
 * @Date: 2021/9/2
 * @version: 1.0
 */
//1.创建一个实现了Runnable接口的类
class MyThread4 implements Runnable{
    // 2.实现类去实现Runnable中的抽象方法：run()
    @Override
    public void run() {
        for (int i = 0; i <= 100; i++) {
            if(i % 2 == 0){
                System.out.println(Thread.currentThread().getName()+":"+i);
            }
        }
    }
}

public class ThreadTest3 {
    public static void main(String[] args) {
        //3.创建实现类的对象
        MyThread4 myThread4 = new MyThread4();
        //4.将此对象作为参数传递到Thread类的构造器中，创建Thread类的对象
        Thread thread = new Thread(myThread4);
        thread.setName("线程一");
        //5.通过Thread类的对象调用start():①启动线程；②调用当前线程的run()-->调用了Runnable类型中的target的run()
        thread.start();

        //再写一个线程遍历,实现类的对象不需要再创建了，只需要创建一个新的Thread类的对象
        Thread thread1 = new Thread(myThread4);
        thread1.setName("线程二");
        thread1.start();
    }
}

在这里插入图片描述

（3）创建方式三：实现callable接口 →JDK 5.0新增

1.创建一个实现Callable的实现类；
2.实现call方法，将此线程需要执行的操作声明在call()中。call()是有返回值的，如果不想要的话，直接就是return null;即可；
3.创建Callable接口实现类的对象；
4.将此Callable接口实现类的对象传递到FutureTask构造器中，创建FutureTask的对象；
5.将FutureTask的对象作为参数传递到Thread类的构造器中，创建Thread对象，并调用start( )；
6.获取Callable中call方法的返回值。(如果call方法中的返回值是null，则省略第6步)

如何理解实现Callable接口的方式创建多线程比实现Runnable接口的方式创建多线程方式强大？
1.call()可以有返回值的。
2.call()可以抛出异常，被外面的操作捕获，获取异常的信息。
3.Callable是支持泛型的。

package com.java.thread2;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

/**
 * @description:
 * 创建线程的方式三:实现callable接口。-->JDK 5.0新增
 * @author: Fish_Vast
 * @Date: 2021/9/9
 * @version: 1.0
 */

//1.创建一个实现Callable的实现类
class NumTread implements Callable{
    //实现call方法，将此线程需要执行的操作声明在call()中
    @Override
    public Object call() throws Exception {
        int sum = 0;
        for (int i = 1; i <= 100 ; i++) {
            if(i % 2 ==0){
                System.out.println(i);
                sum += i;
            }
        }
        return sum;
    }
}

public class ThreadNew {
    public static void main(String[] args) {
        //3.创建Callable接口实现类的对象
        NumTread numTread = new NumTread();
        //4.将此Callable接口实现类的对象传递到FutureTask构造器中，创建FutureTask的对象
        FutureTask futureTask = new FutureTask(numTread);
        //5.将FutureTask的对象作为参数传递到Thread类的构造器中，创建Thread对象，并调用start()
        Thread t = new Thread(futureTask);
        t.start();

        try {
            //6.获取Callable中call方法的返回值
            //get()返回值即为FutureTask构造器参数Callable实现类重写的call()的返回值。
            Object sum = futureTask.get();
            System.out.println("总和为："+sum);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}

在这里插入图片描述

（4）创建方式四：使用线程池 →JDK 5.0新增

1.提供指定线程数量的线程池
2.执行指定的线程的操作。需要提供实现Runnable接口或Callable接口实现类的对象。
3.关闭连接池

使用线程池的好处
1.提高响应速度（减少了创建新线程的时间）
2.降低资源消耗（重复利用线程池中线程，不需要每次都创建）
3.便于线程管理
▷ (1)corePoolSize：核心池的大小
▷ (2)maximumPoolSize：最大线程数
▷ (3)keepAliveTime：线程没有任务时最多保持多长时间后会终止

package com.java.thread2;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadPoolExecutor;

/**
 * @description:
 * 创建线程的方式四：使用线程池
 * @author: Fish_Vast
 * @Date: 2021/9/9
 * @version: 1.0
 */

class NumberThread implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i <= 100; i++) {
            if(i % 2 ==0){
                System.out.println(Thread.currentThread().getName()+":"+i);
            }
        }
    }
}

public class ThreadPool {
    public static void main(String[] args) {
        //1.提供指定线程数量的线程池
        ExecutorService service = Executors.newFixedThreadPool(10);

//        System.out.println(service.getClass());

        ThreadPoolExecutor service1 = (ThreadPoolExecutor) service;//强制类型转换

        service1.setCorePoolSize(15);

        //2.执行指定的线程的操作。需要提供实现Runnable接口或Callable接口实现类的对象
        service.execute(new NumberThread());//适合适用于Runnable
       // service.submit();//适合适用于Callable
        //3.关闭连接池
        service.shutdown();
    }
}

在这里插入图片描述

测试Thread中的常用方法

1.start()：启动当前线程；调用当前线程的run()；
2.run()：通常需要重写Thread类中的此方法，将创建的线程要执行的操作声明在此方法中；
3.currentThread()：静态方法，返回执行当前代码的线程；
4.getName()：获取当前线程的名字；
5.setName()：设置当前线程的名字；
6.yield()：释放当前的cpu的执行权；
7.join()：在线程a中调用线程b的join()，此时线程a就进入阻塞状态，直到线程b完全执行完以后，线程a才结束阻塞状态；
8.sleep(long millitime)：让当前线程“睡眠”指定的millitime毫秒。在指定的millitime毫秒时间内，当前线程是阻塞状态；
9.isAlive()：判断当前线程是否存活。

线程的优先级

1.（1）MAX_PRIORITY：10；
  （2）MIN_PRIORITY：1；
  （3）NORM_PRIORITY：5 （默认的优先级）
2.如何获取和设置当前线程的优先级：
getPriority()：获取线程的优先级
setPriority(int P)：设置线程的优先级
说明： 高优先级的线程要抢占低优先级线程cpu的执行权。但是只是从概率上讲，高优先级的线程高概率的情况下被执行。并不意味着只有当高优先级的线程执行完以后，低优先级的线程才执行。

线程的生命周期

在这里插入图片描述

线程的同步

例题：
模拟火车站售票程序，开启三个窗口售票。

package com.java.thread;
/**
 * @description:
 * 通过Thread继承的方式，创建三个窗口卖票，总票数为100
 * 存在线程的安全问题，待解决！
 * @author: Fish_Vast
 * @Date: 2021/9/2
 * @version: 1.0
 */

class Window extends Thread{
	//ticket必须声明为静态变量，保证三个窗口共用的是一份数据！
    private static int ticket = 100;

    @Override
    public void run() {
        while (true){
            if(ticket > 0){
                System.out.println(currentThread().getName()+"—>卖出票号为:"+ticket);
                ticket--;
            }else{
                break;
            }
        }
    }
}

public class WindowTest {
    public static void main(String[] args) {
        Window window1 = new Window();
        Window window2 = new Window();
        Window window3 = new Window();

        window1.setName("窗口一");
        window2.setName("窗口二");
        window3.setName("窗口三");

        window1.start();
        window2.start();
        window3.start();
    }
}

在这里插入图片描述

package com.java.thread;
/**
 * @description:
 * 通过Runnable接口的方式，创建三个窗口卖票，总票数为100
 * 存在线程的安全问题，待解决！
 * @author: Fish_Vast
 * @Date: 2021/9/2
 * @version: 1.0
 */

class Window2 implements Runnable{
    private int ticket = 100;
    @Override
    public void run() {
        while(true){
            if(ticket > 0){
                System.out.println(Thread.currentThread().getName()+":"+ticket);
                ticket --;
            }else{
                break;
            }
        }
    }
}

public class WindowTest2 {
    public static void main(String[] args) {
        Window2 window2 = new Window2();

        Thread thread = new Thread(window2);
        Thread thread2 = new Thread(window2);
        Thread thread3 = new Thread(window2);

        thread.setName("窗口一");
        thread2.setName("窗口二");
        thread3.setName("窗口三");

        thread.start();
        thread2.start();
        thread3.start();
    }
}

在这里插入图片描述
1.问题：卖票过程中，出现了重票、错票–>出现了线程的安全问题
2.出现问题的原因：当某个线程操作车票的过程中，尚未操作完成时，其他线程参与进来，也操作车票
3.如何解决：当一个线程a在操作ticket的时候，其他线程不能够参与进来。直到线程a操作完ticket时，线程才可以开始操作ticket。这种情况及时线程a出现了阻塞，也不能改变。
4.在java中，我们通过同步机制，来解决线程的安全问题。
5.同步的方式：解决了线程的安全问题。(好处)
     操作同步代码时，只能有一个线程参与，其他线程等待。相当于是一个单线程的过程，效率低。(局限性)
    由以上的例题可以看出多线程出现了安全问题，买票出现了重票或者错票的情况。在此，我们引入线程的同步的概念，解决线程安全问题。

（1）方式一：同步代码块

synchronized(同步监视器){
//需要被同步的代码
}

说明：
(1)操作共享数据的代码。即为需要被同步的代码。–>不能包含代码多了，也不能包含代码少了
(2)共享数据：多个线程共同操作的变量。
(3)同步监视器：俗称：“锁”。任何一个类的对象，都可以充当锁。
要求：多个线程必须要共用同一把锁。

补充：
在实现Runnable接口创建多线程的方式中，我们可以考虑使用this来充当同步监视器。
在继承Thread类创建多线程的方式中，慎用this充当同步监视器，考虑使用当前类充当同步监视器。

package com.java.thread;
/**
 * @description:
 * 使用同步代码块处理继承Thread类来处理安全问题！
 * @author: Fish_Vast
 * @Date: 2021/9/2
 * @version: 1.0
 */

class Window extends Thread{
    private static int ticket = 100;
    private static Object object = new Object();

    @Override
    public void run() {
        while (true) {
            synchronized (object) {
          //synchronized(Window.class){  这个也是可以的
                //Class clazz = Window.class ,Window2.class只会加载一次。
          //synchronized(this){  不用使用，因为此时this代表着window1,window2,window3这三个对象。
                if (ticket > 0) {
                    try {
                        Thread.sleep(5);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(currentThread().getName() + "—>卖出票号为:" + ticket);
                    ticket--;
                } else {
                    break;
                }
            }
        }
    }
}

public class WindowTest {
    public static void main(String[] args) {
        Window window1 = new Window();
        Window window2 = new Window();
        Window window3 = new Window();

        window1.setName("窗口1");
        window2.setName("窗口2");
        window3.setName("窗口3");

        window1.start();
        window2.start();
        window3.start();
    }
}

在这里插入图片描述

package com.java.thread;
/**
 * @description:
 * 使用同步代码块解决实现Runnable接口的线程安全问题
 * @author: Fish_Vast
 * @Date: 2021/9/2
 * @version: 1.0
 */

class Window2 implements Runnable{
    private int ticket = 100;
    Object object = new Object();
    @Override
    public void run() {
        while(true) {
            synchronized (object) { //方式一synchronized(对象)
          //synchronized(this){ 方式二，this代表着window2这一个对象
                if (ticket > 0) {

                    try {
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }

                    System.out.println(Thread.currentThread().getName() + "—>卖出票号为:" + ticket);
                    ticket--;
                } else {
                    break;
                }
            }
        }
    }
}

public class WindowTest2 {
    public static void main(String[] args) {
        Window2 window2 = new Window2();

        Thread thread = new Thread(window2);
        Thread thread2 = new Thread(window2);
        Thread thread3 = new Thread(window2);

        thread.setName("窗口1");
        thread2.setName("窗口2");
        thread3.setName("窗口3");

        thread.start();
        thread2.start();
        thread3.start();
    }
}

在这里插入图片描述

（2）方式二：同步方法

如果操作共享数据的代码完整的声明在一个方法中，我们不妨将此方法声明同步的。
(1)同步方法仍然涉及到同步监视器，只是不需要我们显式的声明。
(2)非静态的同步方法，同步监视器是：this
  静态的同步方法，同步监视器是：当前类本身

package com.java.thread;

/**
 * @description:
 * 使用同步方法处理继承Thread类来处理安全问题！
 * @author: Fish_Vast
 * @Date: 2021/9/6
 * @version: 1.0
 */
class Window5 extends Thread{
    private static int ticket = 100;

    @Override
    public void run() {
        while (true) {
                show();
            }
        }
    public static synchronized void show(){    //正确的，同步监视器为：Window4.class
    //public synchronized void show(){    //同步监视器： window1,window2,window3。此种解决方法是错误的。
        if (ticket > 0) {
            try {
                Thread.sleep(5);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "—>卖出票号为:" + ticket);
            ticket--;
        }
    }
}

public class WindowTest5 {
    public static void main(String[] args) {
        Window5 window1 = new Window5();
        Window5 window2 = new Window5();
        Window5 window3 = new Window5();

        window1.setName("窗口1");
        window2.setName("窗口2");
        window3.setName("窗口3");

        window1.start();
        window2.start();
        window3.start();
    }
}

在这里插入图片描述

package com.java.thread;

/**
 * @description:
 * 使用同步方法解决实现Runnable接口的线程安全问题
 * @author: Fish_Vast
 * @Date: 2021/9/6
 * @version: 1.0
 */

class Window4 implements Runnable{
    private int ticket = 100;
    @Override
    public void run() {
        while(true) {
            show();
        }
    }
    public synchronized void show(){ //同步监视器：this
        if (ticket > 0) {

            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            System.out.println(Thread.currentThread().getName() + "—>卖出票号为:" + ticket);
            ticket--;
        }
    }
}

public class WindowTest4 {
    public static void main(String[] args) {
        Window4 window4 = new Window4();

        Thread thread1 = new Thread(window4);
        Thread thread2 = new Thread(window4);
        Thread thread3 = new Thread(window4);

        thread1.setName("窗口1");
        thread2.setName("窗口2");
        thread3.setName("窗口3");

        thread1.start();
        thread2.start();
        thread3.start();
    }
}

在这里插入图片描述

（3）方式三：lock锁 →JDK5.0新增

1.实例化ReentrantLock
2.调用锁定的方法lock()
3.调用解锁的方法unlock()

package com.java.thread2;

import java.util.concurrent.locks.ReentrantLock;

/**
 * @description:
 * 解决线程安全问题的方式三：lock锁 ---JDK5.0新增
 * @author: Fish_Vast
 * @Date: 2021/9/7
 * @version: 1.0
 */

class Window implements Runnable{
    //注意：这里使用的是Runnable实现的方式。如果使用的是继承的方式，那么这里创建的lock对象必须是静态，保证使用的是同一对象。
    private int ticket = 100;
    //1.实例化ReentrantLock
    private ReentrantLock lock = new ReentrantLock(true);
    @Override
    public void run() {
        while(true){
            try{
                //2.调用锁定的方法lock()
                lock.lock();
                if(ticket > 0){
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + ":售票,票号为:"+ticket);
                    ticket--;
                }else{
                    break;
                }
            }finally {
                //3.调用解锁的方法unlock()
                lock.unlock();
            }
        }
    }
}

public class LockTest {
    public static void main(String[] args) {
        Window w = new Window();

        Thread t1 = new Thread(w);
        Thread t2 = new Thread(w);
        Thread t3 = new Thread(w);

        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");

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

在这里插入图片描述

synchronized与lock的异同？
1、相同点：二者都可以解决线程安全问题
2、不同点：（1）synchronized机制在执行完相应的同步代码以后，自动的释放同步监视器
               （2）lock需要手动的启动同步(lock())，同时结束同步也需要手动的实现(unlock())

解决线程安全问题的优先使用顺序：
Lock →同步代码块（已经进入了方法体，分配了相应资源）→同步方法（在方法体之外）

线程的通信

（1）线程通信涉及到的三个方法

1.wait():一旦执行此方法，当前线程就进入阻塞状态，并释放同步监视器；
2.notify():一旦执行此方法，就会唤醒被wait()的一个线程，如果有多个线程被wait，就唤醒优先级高的那个；
3.notify():一旦执行此方法，就会唤醒所有被wait的线程。

（2）说明

1.wait(),notify(),notifyAll()三个方法必须使用在同步代码块或同步方法中；
2.wait(),notify(),notifyAll()三个方法的调用者必须是同步代码块或同步方法中的同步监视器。否则，会出现IllegalMonitorStateException异常；
3.wait(),notify(),notifyAll()三个方法是定义在java.lang.Object类当中的。

（3）sleep( ) 和 wait( )的异同

1.相同点: 一旦执行方法，都可以使得当前的线程进入阻塞状态。
2.不同点: (1) 两个方法声明的位置不同：Thread类中声明sleep()，Object类中声明wait()；
         (2) 调用的要求不同：sleep()可以在任何需要的场景下调用。wait()必须使用在同步代码块或同步方法中；
         (3) 关于是否释放同步监视器：如果两个方法都使用在同步代码块或同步方法中，sleep()不会释放锁，wait()会释放锁。

经典例题：生产者/消费者问题

package com.java.thread2;

/**
 * @description: 
 * 生产者(Productor)将产品交给店员(Clerk)，而消费者(Customer)从店员处取走产品，店员一次只能持有固定数量的产品(比如:20），
 * 如果生产者试图生产更多的产品，店员会叫生产者停一下，如果店中有空位放产品了再通知生产者继续生产；如果店中没有产品了，
 * 店员会告诉消费者等一下，如果店中有产品了再通知消费者来取走产品。
 *
 * 这里可能出现两个问题：
 * 生产者比消费者快时，消费者会漏掉一些数据没有取到。
 * 消费者比生产者快时，消费者会取相同的数据。
 *
 * 分析：
 * 1.是否是多线程问题？是，生产者线程，消费者线程
 * 2.是否有共享数据？是，店员(或产品)
 * 3.如何解决线程的安全问题？同步机制，有三种方法
 * 4.是否涉及线程的通信？是
 * @author: Fish_Vast
 * @Date: 2021/9/9
 * @version: 1.0
 */

class Clerk{
    private int product = 0;
    //生产产品
    public synchronized void produceProduct(){
        while (true){
            if(product < 20){
                product++;
                System.out.println(Thread.currentThread().getName()+":开始生产第"+product+"产品");
                notify();
            }else{
                try {
                    wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
    //消费产品
    public synchronized void consumeProduct(){
        while(true){
            if(product > 0){
                System.out.println(Thread.currentThread().getName()+":开始消费第"+product+"产品");
                product--;
                notify();
            }else{
                try {
                    wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }

}

class Producer extends Thread{
    private Clerk clerk;

    public Producer(Clerk clerk) {
        this.clerk = clerk;
    }
    //生产者进行生产
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"开始生产产品... ...");

        while(true){
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            clerk.produceProduct();
        }

    }
}

class Customer2 extends Thread{
    private Clerk clerk;

    public Customer2(Clerk clerk) {
        this.clerk = clerk;
    }
    //消费者进行消费
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"开始消费产品... ...");

        while(true){
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            clerk.consumeProduct();
        }

    }
}

public class ProductTest {
    public static void main(String[] args) {
        Clerk clerk = new Clerk();
        Producer p = new Producer(clerk);
        Customer2 c = new Customer2(clerk);
        p.setName("生产者");
        c.setName("消费者");
        p.start();
        c.start();
    }
}

在这里插入图片描述
以上便是Java之多线程的相关知识梳理，编写不易，路过的朋友，如果博客内容对你有所帮助的话，希望能一键三连一下呀，谢谢支持哦！
在这里插入图片描述

Fish_Vast
关注
  • 3
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
JAVA之多线程（基础图）
02-20
JAVA之多线程（基础图）
JAVA之多线程
01-23
JAVA基础学习，java基础ppt，学习java从最基本的做起，夯实基础。
Java之多线程(6个demo)
nuist_NJUPT的博客
08-06 3284
本文主要介绍Java中多线程，在Java中启动多线程的方法包括：继承Thread类或者实现Runnable接口，介绍了设置线程名称，设置线程优先级，设置守护线程等，介绍了线程同步，使用synchronized关键字和lock锁分别实现线程同步，解决线程安全问题，介绍了生产者和消费者模式，涉及线程延迟，等待，唤醒的方法。...
java多线程（超详细）
热门推荐
zdl66的博客
08-14 9万+
进程就是正在运行中的程序（进程是驻留在内存中的）是系统执行资源分配和调度的独立单位每一进程都有属于自己的存储空间和系统资源注意：进程A和进程B的内存独立不共享。
Java多线程案例之线程池
trong_ 的烂笔头
01-30 5364
介绍线程池的原理和简单实现, 进一步提高并发编程的效率.
Java多线程之线程安全问题
trong_ 的烂笔头
12-26 5373
Java多线程中的线程安全问题, 解决方法, 线程安全和不安全的标准类.
【Java多线程】停止线程
一定要站在自己热爱的生活里闪闪发光
10-03 5万+
目录 1. 停止线程的方法 2. 判断线程是否是停止状态 3. 能停止的线程——异常法 4. 在沉睡中停止 5. 能停止的线程——暴力停止 6. 方法stop()与java,lang.ThreadDeath异常 7. 使用return停止线程 1. 停止线程的方法 在Java中有以下3种方法可以终止正在进行的线程： 1）使用退出标志，使线程正常退出，也就是当run方法完成后线程终止。 2）使用stop方法强行终止线程，但是不推荐使用这个方法，因为stop和suspend及resum
java多线程使用教程
鹏鹏2077
04-25 5229
本教程介绍了Java多线程的基本知识和使用方法，包括创建线程、实现Runnable接口、继承Thread类、线程同步、线程间通信和线程池等。多线程技术可以提高程序的并发处理能力和响应速度，但同时也带来了线程安全和同步等问题，需要合理使用同步机制来保证线程安全。使用Java提供的Lock接口可以实现更加灵活和精细的线程同步。线程间通信可以使用wait()、notify()和notifyAll()方法来实现。线程池机制可以重用线程，提高了线程的利用率和效率。掌握了这些知识，可以使用Java实现高效、安全、可靠的
JAVA多线程是什么
qq_45022104的博客
08-31 4010
一、 什么是多线程： 我们现在所使用操作系统都是多任务操作系统(早期使用的DOS操作系统为单任务操作系统)，多任务操作指在同一时刻可以同时做多件事(可以同时执行多个程序)。 多进程:每个程序都是一个进程，在操作系统中可以同时执行多个程序,多进程的目的是为了有效的使用CPU资源，每开一个进程系统要为该进程分配相关的系统资源(内存资源) 多线程:线程是进程内部比进程更小的执行单元(执行流|程序片段),每个线程完成一个任务,每个进程内部包含了多个线程每个线程做自己的事情，在进程中的所有线程共享该进程的资源； 主
java多线程之yield方法
GodSure0914的博客
02-25 2293
Thread.yield()方法作用是：暂停当前正在执行的线程对象，并执行其他线程。 yield()让当前运行线程回到可运行状态，以允许具有相同优先级的其他线程获得运行机会。因此，使用yield()的目的是让相同优先级的线程之间能适当的轮转执行。但是，实际中无法保证yield()达到让步目的，因为让步的线程还有可能被线程调度程序再次选中。 import lombok.Data /** * @author Admin * @date 2021/2/25 9:41 */ @Data publi
Java多线程-CountDownLatch
weixin_45203607的博客
02-16 2552
介绍 CountDownLatch是一个同步辅助类，它允许一个或多个线程一直等待直到其他线程执行完毕才开始执行。 用给定的计数初始化CountDownLatch，其含义是要被等待执行完的线程个数。 每次调用CountDown()，计数减1 主程序执行到await()函数会阻塞等待线程的执行，直到计数为0 场景 1:多线程读取批量文件, 并且读取完成之后汇总处理 2:多线程读取Excel多个sheet,读取完成之后获取汇总获取的结果 3:多个人一起一起来吃饭,主人等待客人到来,客人一个个从不同地方来到饭店,主
Java之多线程学习代码
05-06
Java之多线程学习代码
Java多线程编程总结
01-31
要认识多线程就要从操作系统的原理说起。以前古老的DOS操作系统（V6.22）是单任务的，还没有线程的概念，系统在每次只能做一件事情。比如你在copy东西的时候不能rename文件名。为了提高系统的利用效率，采用批处理来...
Java多线程详解及示例
07-20
本文将深入探讨Java多线程编程的重要性和使用方法。介绍多线程概念，讨论多线程的优势，并提供实际示例。此外，还将探讨多线程编程中的常见问题以及如何避免这些问题。通过本文，您将获得对Java多线程编程的全面理解...
jar包增量更新分析
junlaiyan的专栏
05-16 373
借助jdeps分析出jar包的增量文件
分布式锁2-Zookeeper分布式锁实战
最新发布
qq_43676797的博客
05-19 213
使用curator操作Zookeeper进行实战；：Apache Curator包含一套高级API框架和工具类，它 是Apache ZooKeeper 的Java 客户端库。
命令执行漏洞（二）
XLbb的博客
05-15 1004
POST方法，S2-045-bypass-2漏洞存在！,程序更改为S2-045-bypass-2漏洞测试模式, 响应码: 200。POST方法，S2-046-bypass漏洞存在！POST方法，S2-045-bypass漏洞存在！POST方法，S2-046-1漏洞存在！POST方法，S2-046-2漏洞存在！POST方法，S2-046-3漏洞存在！POST方法，S2-045-1漏洞存在！POST方法，S2-045-3漏洞存在！POST方法，S2-045-2漏洞存在！POST方法，S2-045-4漏洞存在！
java数据结构与算法(验证二叉搜索树)
磐门的博客
05-17 340
节点返回空为ture,节点的值不在对应数据大小范围内返回false。将验证二叉搜索树计算同样可以转换为相同子问题，所以比较适合用递归。node为root的左节点时，max更新为root.val。node为root的右节点时，min更新为root.val。
java 创建多线程
04-14
以下是两种Java创建多线程的例子： 1. 继承Thread类创建多线程[^1] java public class MyThread extends Thread { @Override public void run() { System.out.println("使用继承Thread类创建多线程"); } ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Fish_Vast

您的打赏是对我最大的支持！！！

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值