Java学习笔记：多线程

最新推荐文章于 2024-11-13 20:43:20 发布
最新推荐文章于 2024-11-13 20:43:20 发布
阅读量553 收藏
点赞数
分类专栏： 基础 文章标签： java idea
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_52214366/article/details/121486004
版权

目录

多线程

1. 基本概念

程序（program）：是为完成特定任务、用某种语言编写的一组指令的集合。即指一段静态的代码，静态对象。

进程（process）：是程序的一次执行过程，或是正在运行的一个程序。是一个动态的过程：有它自身的产生、存在和消亡的过程。也就是它的生命周期。进程作为资源分配的单位，系统在运行时会为每个进程分配不同的内存区域。

线程（thread）：进程可进一步细化为线程，是一个程序内部的一条执行路径。若一个进程同一时间并行执行多个线程，就是支持多线程的。线程作为调度和执行的单位，每个线程拥有独立的运行栈和程序计数器（pc），线程切换的开销小。

一个进程中的多个线程共享相同的内存单元/内存地址空间->它们从同一堆中分配对象，可以访问相同的变量和对象，这就使得线程间通信更简便、高效。但多个线程操作共享的系统资源可能就会带来安全隐患。

一个Java程序java.exe，至少有三个线程：main()主线程，gc()垃圾回收线程，异常处理线程。如果发生异常，会影响主线程。

并行和并发：

  • 并行：多个CPU同时执行多个任务。
  • 并发：一个CPU（采用时间片）同时执行多个任务。

多线程程序的优点：

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

**线程的分类：**守护线程和用户线程

  • 它们基本上都是相同的。唯一的区别在于判断JVM何时离开
  • 守护线程是用来服务用户线程的，通过在start()方法前调用thread.setDaemon(true)可以把一个用户线程变成一个守护线程
  • Java垃圾回收就是一个守护线程
  • 若JVM中都是守护线程，当前JVM将退出

2. Thread类的常用方法

方法说明
void start()启动线程，并执行对象的run()方法
run()线程在被调度时执行的操作，通常需要重写Thread类中的此方法，将创建的线程要执行的操作声明在此方法中
String getName()获取当前线程的名称
void setName(String name)设置当前线程的名称，一般在start()之前设置名字
static Thread currentThread()返回执行当前代码的线程。在Thread子类中就是this，通常用于主线程和Runnable实现类
static void yield()线程让步。暂停当前正在执行的线程，把执行机会让给优先级相同或更高的线程。若队列中没有同优先级的线程，忽略此方法
join()当某个程序执行流中调用其他线程的join()方法时，调用线程将被阻塞，直到join()方法加入的join线程执行完为止。低优先级的线程也可以获得执行
static void sleep(long millis)指定时间：毫秒。令当前活动线程在指定时间段内放弃对CPU的控制，使其他线程有机会被执行，时间到后重新排队。抛出InterruptedException异常
stop()强制线程生命期结束，不推荐使用
boolean isAlive()返回boolean，判断线程是否还活着

简单实现：

public class demo03 {
    public static void main(String[] args) {
        MyThread3 myThread01 = new MyThread3();
        myThread01.setName("线程一");  //给线程设置名字，一般在该线程调用start()之前设置
        myThread01.start();
        Thread.currentThread().setName("主线程");  //给主线程命名

        for (int i = 0; i < 100; i++) {
            if (i % 2 == 0) {
                System.out.println(Thread.currentThread().getName() + "：" + i);//获取执行当前代码的线程名字
            }
            if (i == 20){
                try {
                    myThread01.join();  //在线程a中调用线程b的join()，此时线程a就进入阻塞状态，直到线程b完全执行完后，线程a才结束阻塞状态
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
        System.out.println(myThread01.isAlive());   //判断当前线程是否存活
        MyThread3 myThread02 = new MyThread3("Thread：1");  //通过有参构造器给线程命名

    }
}
class MyThread3 extends Thread{
    public MyThread3(String name) {
        super(name);
    }

    public MyThread3() {
    }

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            if (i % 2 == 0){
                try {
                    sleep(1000);   //让当前线程“睡眠”指定的millis毫秒，在指定的millis毫秒时间内，当前线程是阻塞状态
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName()+"："+i);//获取执行当前代码的线程名字
            }
//            if (i % 20 == 0){
//                yield();     //释放当前CPU的执行权
//            }
        }
    }
}

3. 线程的调度

Java的调度方法：

  • 同优先级线程组成先进先出队列（先到先服务），使用时间片策略
  • 对高优先级，使用优先调度的抢占式策略

线程的优先级等级：

  • MAX_PRIORITY ：10（最高）
  • MIN_PRIORITY ：1（最低）
  • NORM_PRIORITY ：5（默认）

方法：

  • getPriority()：返回线程优先级
  • setPriority(int newPriority)：改变线程的优先级

**注：**高优先级的线程要抢占低优先级线程CPU的执行权。但只是从概率上讲，高优先级的线程高概率的情况下被执行，并不意味着只有当高优先级的线程执行完之后，低优先级的线程才执行。

myThread01.setPriority(Thread.MAX_PRIORITY);   //设置分线程的优先级
System.out.println(Thread.currentThread().getPriority());  //获取执行当前代码的线程优先级，默认为5（包括主线程）

4. 多线程的创建和使用

4.1 创建方式一：继承Thread类

思路分析：

  1. 创建一个继承于Thread类的子类
  2. 重写Thread类的run()，将此线程执行的操作声明在run()中
  3. 创建Thread类的子类的对象
  4. 通过此对象调用start()
public class demo01 {
    public static void main(String[] args) {
        MyThread t1 = new MyThread();
        t1.start();   //start()方法：启动当前线程，调用当前线程的run()方法
        t1.run();     //调用run()方法，但线程还是主线程，不会新开一个线程，所以不能之间调用run()的方式启动线程
        t1.start();   //再启动一个线程，不可以让已经start()的线程去执行，会报IllegalThreadStateException异常，此时需要再new一个线程的对象，再启动即可
        
        //创建Thread类的匿名子类的方式
        new Thread(){
            @Override
            public void run() {
                super.run();
            }
        }.start();
    }
}
class MyThread extends Thread{   //继承了Thread的子类
    @Override
    public void run() {         //重写Thread类的run()
        for (int i = 0; i < 100; i++) {
            if (i % 2 == 0){     //输出100以内的偶数
                //Thread.currentThread().getName()：打印当前线程名字
                System.out.println(Thread.currentThread().getName() + "：" + i);
            }
        }
    }
}

4.2 创建方式二：实现Runnable接口

思路分析：

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

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {  //实现Runnable中的抽象方法
            if (i % 2 == 0){
                System.out.println(Thread.currentThread().getName() + "："+i);
            }
        }
    }
}
public class demo04 {
    public static void main(String[] args) {
        MThread mThread = new MThread();  //创建实现类的对象
        Thread thread = new Thread(mThread);  //将此对象作为参数传递到Thread类的构造器中
        thread.start();  //通过Tread类的对象调用start()：1.启动线程 2.调用当前线程的run() 3.调用了Runnable类型的target的run()
        Thread thread2 = new Thread(mThread);  //再启动一个线程
        thread2.start();
    }
}

4.3 以上两种创建线程的方式的比较

  1. 开发中：优先选择实现Runnable接口的方式
    1. 实现的方式没有类的单继承性的局限性
    2. 实现的方式更适合来处理多个线程有共享数据的情况
  2. 联系：public class Thread implements Runnable
  3. 相同点：两种方式都需要重写run()，将线程要执行的逻辑声明在run()中。这两种方式要想启动线程，都是调用Thread类中的start()方法。

4.4 JDK5.0新增线程创建方式

4.4.1 实现Callable接口

与使用Runnable相比：

  • 相比run()方法，call()可以有返回值
  • call()方法可以抛出异常，被外面的操作捕获，获取异常的信息
  • 支持泛型的返回值
  • 需要借助Future Task类，比如获取返回结果

综上所述，使用实现Callable接口比实现Runnable接口创建多线程更强大。

Future接口：

  • 可以对具体Runnable、Callable任务的执行结果进行取消、查询是否完成、获取结果等
  • Future Task是Future接口的唯一实现类
  • Future Task同时实现了Runnable，Future接口。它既可以作为Runnable被线程执行，又可以作为Future得到Callable的返回值

思路分析：

  1. 创建一个实现Callable实现类
  2. 实现call()方法，将此线程需要执行的操作声明在call()中，可以有返回值，如果不需要返回值，返回null
  3. 创建Callable接口实现类的对象
  4. 将此Callable接口实现类的对象作为传递到FutureTask构造器中，创建FutureTask的对象
  5. 将FutureTask的对象作为参数传递到Thread类的构造器中，创建Thread对象，并调用start()方法
  6. 获取Callable中的call()方法的返回值
class NumThread implements Callable<Integer>{  //创建一个Callable实现类

    @Override
    public Integer call() throws Exception {  //实现call()方法
        int sum = 0;
        for (int i = 1; i <= 100; i++) {
            if (i % 2 == 0){
                System.out.println(i);
                sum += i;
            }
        }
        return sum;
    }
}
public class demo05 {
    public static void main(String[] args) {
        NumThread numThread = new NumThread();  //创建Callable接口实现类的对象
        FutureTask<Integer> futureTask = new FutureTask<Integer>(numThread);  //创建FutureTask的对象
        new Thread(futureTask).start(); //将FutureTask的对象作为参数传递到Thread类的构造器中，创建Thread对象，并调用start()方法
        try {
            //get()返回值为FutureTask构造器参数Callable实现类重写的call()的返回值
            System.out.println("总和："+futureTask.get());
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}
4.4.2 使用线程池

经常创建和销毁、使用量特别大的资源，比如并发情况下的线程，对性能影响很大。此时就可以使用线程池，提前创建好多个线程，放入线程池中，使用时直接获取，使用完放回池中。可以避免频繁创建销毁、实现重复利用。

优点：

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

线程池相关API：ExecutorService和Executors：

  • ExecutorService：真正的线程池接口。常见子类ThreadPoolExecutor
    • void execute(Runnable command)：执行任务/命令，没有返回值，一般用来执行Runnable
    • < T > Future < T > submit(Callable< T > task)：执行任务，有返回值，一般又来执行Callable
    • void shutdown()：关闭连接池
  • Executors：工具类、线程池的工厂类，用于创建并返回不同类型的线程池
    • Executors.newCachedThreadPool()：创建一个可根据需要创建新线程的线程池
    • Executors.newFixedThreadPool(n)：创建一个可重用固定线程数的线程池
    • Executors.newSingleThreadExecutor()：创建一个只有一个线程的线程池
    • Executors.newScheduledThreadPool(n)：创建一个线程池，它可安排在给定延迟后运行命令或者定期地执行

思路分析：

  1. 提供指定线程数量的线程池
  2. 执行指定的线程的操作。需要提供实现Runnable接口或Callable接口实现类的对象
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) {
        ExecutorService service = Executors.newFixedThreadPool(10);//提供指定线程数量的线程池
        
        System.out.println(service.getClass());  //getClass()是Object类的方法，获取当前对象是哪个类的
        //由于ExecutorService是接口，接口中都是常量，所以不能直接设置
        //类当中的属性可以是变量，所以可以通过强转设置接口的属性
        ThreadPoolExecutor service1 = (ThreadPoolExecutor) service;
        service1.setCorePoolSize(15);
        
        //执行指定的线程的操作。需要提供实现Runnable接口或Callable接口实现类的对象
        service.execute(new NumberThread());  //适合使用于Runnable
        //service.submit(Callable callable);  //适合使用于Callable
        service.shutdown();  //关闭线程池
    }
}

5. 线程的生命周期

JDK中用Thread.State类定义了线程的五种状态：

  • 新建：当一个Thread类或其子类的对象被声明并创建时，新生的线程对象处于新建状态
  • 就绪：处于新建状态的线程被start()后，将进入线程队列等待CPU时间片，此时它已经具备了运行的条件，只是没有分配到CPU资源
  • 运行：当就绪的线程被调度并获得CPU资源时，便进入运行状态，run()方法定义了线程的操作和功能
  • 阻塞：在某种特殊情况下，被人为挂起或执行输入输出操作时，让出CPU并临时中止自己的执行，进入阻塞状态
  • 死亡：线程完成了它的全部工作或线程被提前强制性地中止或出现异常导致结束

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-MKhCynwP-1637630926787)(E:\Notes\Java\picture\线程生命周期.jpg)]

6. 线程的同步

用于解决线程的安全问题。

局限性：操作同步代码时，只能有一个线程参与，其他线程等待，这相当于是一个单线程的过程，效率低。但由于线程可能会不安全，所以还是需要使用同步。

在Java中，通过同步机制，来解决线程的安全问题。

实际问题：

题目：三个窗口卖票，总票数为100张，使用实现Runnable接口的方式

class Window1 implements Runnable{    //实现了Runnable接口的类
    private int ticket = 100;
    @Override
    public void run() {
        while (true){
            if (ticket > 0){
                try {
                        Thread.sleep(100);   //加大了出现重票和错票的几率
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                System.out.println(Thread.currentThread().getName() + "：卖票，票号为：" + ticket);
                ticket--;
            }else {
                break;
            }
        }
    }
}
public class WindowTest02 {
    public static void main(String[] args) {
        Window1 window1 = new Window1();
        Thread thread1 = new Thread(window1);
        Thread thread2 = new Thread(window1);
        Thread thread3 = new Thread(window1);
        thread1.setName("窗口1");
        thread2.setName("窗口2");
        thread3.setName("窗口3");
        thread1.start();
        thread2.start();
        thread3.start();
    }
}
  1. 出现的问题：卖票过程中，出现了重票、错票（即出现了线程安全问题）
  2. 问题出现的原因：当某个线程操作车票的过程中，尚未操作完成时，其他线程参与进来，也操作车票
  3. 解决：当一个线程在操作共享数据ticket的时候，其他线程不能参与进来，直到此线程操作完ticket后，其他线程才可以开始操作ticket。即使此线程出现了阻塞，也不能被改变

6.1 解决方式一：synchronized

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

说明：

  • 操作共享数据的代码，即为需要被同步的代码
  • 共享数据：多个线程共同操作的变量。比如以上问题中的ticket就是共享数据。
  • 同步监视器：俗称“锁”。任何一个类的对象都可以充当锁
    • 要求：多个线程必须共用同一把锁。
  • 在实现Runnable接口创建多线程的方式中，可以考虑使用this充当锁。而在继承Thread类创建多线程的方式中，慎用this充当锁，可以考虑使用当前类充当锁。
class Window2 implements Runnable{
    private int ticket = 100;
    Object obj = new Object();
    @Override
    public void run() {
        while (true){
            //添加锁，可以使用任何一个类充当锁，包括当前对象this
            synchronized (this){   //此时的this：唯一的Window2的对象
            //synchronized (obj) {  //可以直接使用this（当前对象），以免多去定义其他的对象
                if (ticket > 0) {
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + "：卖票，票号为：" + ticket);
                    ticket--;
                } else {
                    break;
                }
            }//将所有需要用到共享数据的代码都被synchronized括起来
        }
    }
}
//main()方法同上
6.1.1 同步方法

如果操作共享数据的代码完整的声明在一个方法中，可以直接将此方法声明同步。这就是同步方法。

类型修饰符 (static) synchronized 返回值类型 方法名(){
    //需要被同步的代码
}

说明：

  • 同步方法仍然涉及到同步监视器，只是不需要显式的声明
  • 对于非静态的同步方法来说，同步监视器是：this
  • 对于静态的同步方法来说，同步监视器是：当前类本身
class Window3 implements Runnable{

    private int ticket = 100;
    @Override
    public void run() {
        while (true){
            show();
            if (ticket<=0){   //必须给条件让循环退出，否则程序将一直无法正常退出
                break;
            }
        }
    }
    private synchronized void show(){   //同步方法，同步监视器：this
        if (ticket > 0){
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "：卖票，票号为：" + ticket);
            ticket--;
        }
    }
}
public class WindowTest04 {
    public static void main(String[] args) {
        Window3 window3 = new Window3();
        Thread thread1 = new Thread(window3);
        Thread thread2 = new Thread(window3);
        Thread thread3 = new Thread(window3);
        thread1.setName("窗口1");
        thread2.setName("窗口2");
        thread3.setName("窗口3");
        thread1.start();
        thread2.start();
        thread3.start();
    }
}

6.2 解决方式二：Lock锁

从JDK5.0开始，Java提供了更强大的线程同步机制——通过显式定义同步锁来实现同步。同步锁使用Lock对象充当。

java.util.concurrent.locks.Lock接口时控制多个线程对共享资源进行访问的工具。

ReentrantLock类实现了Lock，它拥有与synchronized相同的并发性和内存语义，在实现线程安全的控制中，比较常用的是ReentrantLock，可以显式加锁和释放锁。

思路分析：

  1. 实例化ReentrantLock对象
  2. 调用锁定方法lock()
  3. 调用解锁方法unlock()
class Windows implements Runnable{

    private int ticket = 100;
    private ReentrantLock lock = new ReentrantLock();  //实例化ReentrantLock
    @Override
    public void run() {
        while (true){
            try {
                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 {
                lock.unlock();  //调用解锁方法unlock()
            }
        }
    }
}
public class LockTest {
    public static void main(String[] args) {
        Windows windows = new Windows();
        Thread thread1 = new Thread(windows);
        Thread thread2 = new Thread(windows);
        Thread thread3 = new Thread(windows);
        thread1.setName("窗口1");
        thread2.setName("窗口2");
        thread3.setName("窗口3");
        thread1.start();
        thread2.start();
        thread3.start();
    }
}

7. 线程的死锁问题

死锁：

  • 不同的线程分别占用对方需要的同步资源不放弃，都在等待对方放弃自己需要的同步资源，就形成了线程的死锁
  • 出现死锁后，不会出现异常，不会出现提示，只是所有的线程都处于阻塞状态，无法继续

解决方法：

  • 专门的算法、原则
  • 尽量减少同步资源的定义
  • 尽量避免嵌套同步
public class DeadLock {
    public static void main(String[] args) {
        StringBuffer s1 = new StringBuffer();
        StringBuffer s2 = new StringBuffer();
        new Thread(){         //假如是此线程先运行
            @Override
            public void run() {
                synchronized (s1){   //拿到锁s1后继续执行
                    s1.append("a");
                    s2.append("1");
                    try {
                        Thread.sleep(100);  //此线程进入阻塞状态，此时CPU将执行另一个线程
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    synchronized (s2){
                        s1.append("b");
                        s2.append("2");
                        System.out.println(s1);
                        System.out.println(s2);
                    }
                }
            }
        }.start();
        new Thread(new Runnable() {   //在此程序中，就是下面这个线程将被执行
            @Override
            public void run() {
                synchronized (s2){   //拿到锁s2后继续执行
                    s1.append("c");
                    s2.append("3");
                    try {
                        Thread.sleep(100);   //此线程也进入阻塞状态
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    synchronized (s1){
                        s1.append("d");
                        s2.append("4");
                        System.out.println(s1);
                        System.out.println(s2);
                    }
                }
            }
        }).start();
        //最后等这两个线程均进入就绪状态后，要执行后面代码时，发现将要拿到的锁被拿了，所以两个线程又陷入阻塞状态，也就是死锁
        //所以在开发中，我们要避免死锁问题，因为出现死锁问题不会有任何提示，只会程序无法正常退出
    }
}

8. 线程的通信

涉及到的三个方法：

wait()：一旦执行此方法，当前线程就进入阻塞状态，并释放同步监视器

notify()：一旦执行此方法，就会唤醒被wait的一个线程。如果有多个线程被wait，就唤醒优先级高的那个线程

notifyAll()：一旦执行此方法，就会唤醒所有被wait的线程

说明：

  1. 这三个线程通信的方法，必须使用在同步代码块或同步方法中
  2. 这三个方法的调用者必须是同步代码块或同步方法中的同步监视器，否则会出现java.lang.IllegalMonitorStateException异常。
  3. 这三个方法是定义在java.lang.Object类中。

基本实现：

class Number implements Runnable{
    private int number = 1;
    @Override
    public void run() {
        while (true){
            synchronized (this) {
                notify();   //唤醒wait
                if (number <= 100){
                    System.out.println(Thread.currentThread().getName() + "：" +number);
                    number++;
                    try {
                        wait();  //使得调用如下wait()方法的线程进入阻塞状态，并释放自己的锁
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }else {
                    break;
                }
            }
        }
    }
}
public class CommunicationTest {
    public static void main(String[] args) {
        Number number = new Number();
        Thread thread1 = new Thread(number);
        Thread thread2 = new Thread(number);
        thread1.setName("线程1");
        thread2.setName("线程2");
        thread1.start();
        thread2.start();
    }
}

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

题目：生产者（Producer）将产品交给店员（Clerk），而消费者（Customer）从店员处取走产品，店员一次只能持有固定数量的产品（如：20），如果生产者试图生产更多的产品，店员会叫生产者停一下，如果店中有空位放产品了再通知生产者继续生产，如果店中没有产品了，店员会告诉消费者等一下，如果店中有产品了再通知消费者来取走产品。

class Clerk{     //店员
    private int productCount = 0;
    public synchronized void produceProduct() {  //生产产品
        if (productCount < 20){
            productCount++;
            System.out.println(Thread.currentThread().getName() + "：开始生产第" + productCount +"个产品");
            notify();
        }else {
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public synchronized void consumeProduct() {   //消费产品
        if (productCount > 0){
            System.out.println(Thread.currentThread().getName() + "：开始消费第"+productCount+"个产品");
            productCount--;
            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 Customer extends Thread{    //消费者
    private Clerk clerk;
    public Customer(Clerk clerk) {
        this.clerk = clerk;
    }

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + "：开始消费产品");
        while (true){
            try {
                Thread.sleep(20);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            clerk.consumeProduct();
        }
    }
}
public class ProductTest {
    public static void main(String[] args) {
        Clerk clerk = new Clerk();
        Producer producer1 = new Producer(clerk);
        producer1.setName("生产者1");
        Customer customer1 = new Customer(clerk);
        customer1.setName("消费者1");
        Customer customer2 = new Customer(clerk);
        customer2.setName("消费者2");
        producer1.start();
        customer1.start();
        customer2.start();
    }
}

9. 关于线程的面试题

9.1 线程同步

1. synchronized与Lock的异同

相同：都可以解决线程安全问题

不同：

  • synchronized机制在执行完相应的同步代码后，自动的释放同步监视器
  • Lock需要手动的启动同步（lock()方法），同时结束同步也需要手动的实现（unlock()方法）

优先使用顺序：

Lock -> 同步代码块（已经进入了方法体，分配了相应资源） -> 同步方法（在方法体之外）

2. 如何解决线程安全问题？有几种方式？

synchronized和Lock，synchronized又分为同步代码块和同步方法。

9.2 sleep()和wait()

sleep()和wait()的异同

  • 相同：一旦执行方法，都可以使得当前线程进入阻塞状态
  • 不同：
    • 两个方法声明的位置不同：sleep()声明在Thread类中，wait()声明在Object类中
    • 调用的要求不同：sleep()可以在任何需要的场景下调用，wait()必须使用在同步代码块或同步方法中
    • 关于是否释放同步监视器：如果两个方法都是用在同步代码块或同步方法中，sleep()不会释放锁，wait()会释放锁
xxxxxsj
关注
专栏目录
Java学习笔记：高阶语法
坤舆湖畔的万某某的博客
09-08 2148
Java多线程、集合、队列、栈等知识的简单介绍与演示。
学习笔记：多线程Java Socket编程示例
08-17
在本学习笔记中，我们将探讨如何使用Java的Socket编程实现多线程服务器，特别是通过ExecutorService创建线程池来处理客户端的并发请求。ExecutorService是一个高级的线程管理工具，它允许我们更有效地管理和控制线程...
单链表（Java实现）
qq_52214366的博客
12-02 952
文章目录1. 单链表1. 定义2. 思路分析3. 实现3.1 自定义结点类3.2 单链表类3.3 单链表的实现方法3.3.1 添加3.3.2 修改3.3.3 删除3.3. 打印4. 常见面试题4.1 求单链表中有效结点的个数4.2 查找单链表中的倒数第k个结点4.3 单链表的反转4.4 从尾到头打印单链表4.5 合并两个有序单链表 1. 单链表 1. 定义 链表（Linked List）：是有序的列表。链表分带头结点的链表和没有头结点的链表，根据实际的需求来确定。链表是以结点的方式来存储，即链式存储。链表的
Java学习笔记：抽象类和接口
qq_52214366的博客
10-18 264
抽象类和接口 1.抽象方法和抽象类 1.1 定义 抽象方法：使用abstract修饰的方法，没有方法体，只有声明。定义的是一种“规范”，就是告诉子类必须要给抽象方法提供具体的实现。 抽象类：包含抽象方法的类就是抽象类。通过abstract方法定义规范，然后要求子类必须定义具体实现。通过抽象类，我们就可以做到严格限制子类的设计，便于子类之间更加通用。抽象类中可以有普通变量和普通方法以及构造方法。 1.2 基本用法 public abstract class Student { //抽象类 pri
异常机制以及自定义异常
weixin_46649583的博客
09-07 1747
异常分类（异常—>Exception） 检查性异常：最具代表的检查性异常是用户错误或问题引起的异常，这是程序员无法预见的。 例如要打开一个不存在的文件时，一个异常就发生了，这些异常在编译时不能被简单地忽略。 运行时异常：运行时异常是可能被程序员避免的异常。与检查性异常相反，运行时异常可以在编译时被忽略。 错误ERROR：错误不是异常，而是脱离程序员控制的问题。错误在代码中通常被忽略。例如，当栈溢出时，一个错误就发生了，它们在编译也检查不到的。 异常体系结构 Error Erro
Java多线程学习笔记
qq_44903634的博客
08-01 1614
wait()会使“当前线程”等待，因为线程进入等待状态，所以线程应该释放它锁持有的“同步锁”，否则其它线程获取不到该“同步锁”而无法运行！其他线程获取“该对象的同步锁”(
Java 多线程学习笔记
2301_76962889的博客
07-13 1920
*进程：**是操作系统进行资源分配和调度的基本单位，是程序的一次执行过程。**例如：**当你打开一个应用程序，如浏览器、音乐播放器等，操作系统就会为其创建一个进程。**线程：**是进程的一个执行单元，是 CPU 调度和分派的基本单位，一个进程可以包含多个线程。**例如：**在浏览器进程中，可以有多个线程同时运行，例如一个线程负责页面渲染，另一个线程负责网络请求。提高 CPU 利用率，充分利用多核处理器**例如：**下载软件使用多线程可以同时下载多个文件片段，充分利用带宽，提高下载速度。
狂神说Java学习笔记——多线程
weixin_65098078的博客
07-19 1586
狂神说Java学习笔记——多线程
Java学习笔记-多线程
cyh0503的博客
07-08 2879
并发与并行 并发：指两个或多个事件在同一个时间段内发生 并行：指两个或多个事件在同一时刻发生（同时发生） 在操作系统中，安装了多个程序，并发指的是在一段时间内宏观上有多个程序同时运行，这在单CPU系统中，每一时刻只能有一道程序执行，即微观上这些程序是分时的交替运行，只不过是给人的感觉是同时运行，那是因为分时交替运行的时间是非常短的。 而在多个CPU系统中，则这些可以并发执行的程序便可以分配到多...
java学习笔记：java所有关键字汇总、解析及应用
迈达量化的博客
01-30 2326
汇总所有java关键字及其用途，并举例说明。
java基础：多线程学习笔记
最新发布
11-14
java基础：多线程学习笔记
读书笔记：多线程学习代码《Java并发编程核心方法与框架》相应代码.zip
07-26
读书笔记：多线程学习代码《Java并发编程核心方法与框架》相应代码
(完整版)最全的java学习笔记(必看).pdf
05-27
Java学习笔记 Java是一种流行的编程语言，广泛应用于Android应用程序开发、Web应用程序开发、桌面应用程序开发等领域。以下是Java学习笔记的摘要信息： 一、Java技术基础 * 1.1 编程语言：Java是一种面向对象的...
Java学习笔记：JavaSe、Spring、JVM、MySQL、MyBatis....zip
02-22
这份"Java学习笔记：JavaSe、Spring、JVM、MySQL、MyBatis....zip"的压缩包文件，包含了Java学习的重要组成部分，旨在帮助初学者或有经验的开发者深入理解Java技术栈。 首先，JavaSe（Java Standard Edition）是...
Servlet的生命周期
wyk的博客
11-13 1043
Servlet 的生命周期包含四个主要阶段：加载与实例化、初始化、请求处理、销毁。开发者可以在这些生命周期方法中编写初始化、请求处理和资源清理的代码，确保 Web 应用程序的正常运行。
日常bug记录，easyexcel导入报错convert data ... to class java.math.BigDecimal error
mm
11-11 297
排查发现实体类中有BigDecimal属性，然而数据中这个属性为null，进行转换时报错。在实体类上加上自定义转换器。解决方法：自定义转换器类。
Java基础07
m0_74977981的博客
11-11 693
如图下图：每个case中都有一个break，如果没有这个break，就不会跳出case，直到遇见break为止。
刷题---顺序表算法题
weixin_63997543的博客
11-11 442
顺序算法题----力扣刷题
Java多线程学习笔记：从基础到深入
资源摘要信息:"多线程笔记_java/多线程_" 知识点： 1. 多线程基础概念： 在Java中，线程（Thread）是程序执行流的最小单位，是操作系统能够进行运算调度的最小单位，它被包含在进程之中，是进程中的实际运作单位...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值