线程的基本操作和原理

最新推荐文章于 2025-03-07 20:01:18 发布

原创最新推荐文章于 2025-03-07 20:01:18 发布 · 154 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#多线程

多线程专栏收录该内容

3 篇文章

订阅专栏

本文解析Thread.join()的使用方法，通过实例说明如何确保线程执行顺序，以及它内部的wait/notify机制。生产者消费者模型中，展示了wait/notify的配合应用。

Thread.join()的使用和原理

public class ThreadJoinDemo {
    private static int x= 0;
    private static int i= 0;

    public static void main(String[] args) throws InterruptedException {

        Thread t1 = new Thread(() -> {
            x = 1;
            i = 2;
        });
        Thread t2 = new Thread(() -> {
            i = x+2;
        });
        //这里两个线程的执行顺序是不确定的，所以打印i的值可能为2，可能为3，
        //加jion方法是保证t1线程执行完成才执行t2，也就是说保证了t1线程的执行结果对t2可见，保证一定等于3
        t1.start();
        //加入join方法保证t1线程执行完成才执行t2，join方法里面其实也是调用了wait方法
        t1.join();
        t2.start();
        Thread.sleep(1000);
        System.out.println("result:"+i);
    }
}

原理图

sleep方法的作用

sleep是什么
使线程暂停执行一段时间，直到等待的时间结束才恢复执行或在这段时间里被中断

sleep的工作流程

1.挂起线程并修改其运行状态
2.用sleep()提供的参数设置一个定时器
3.当时间结束会触发定时器，内核收到中断够会修改线程的运行状态

wait和notify的使用

用一个生产者消费者例子来说明

生产者

public class Producer implements Runnable{
    private  Queue<String> queue;
    private  int size;

    public Producer(Queue<String> queue, int size) {
        this.queue = queue;
        this.size = size;
    }

    @Override
    public void run() {
        int i = 0;
        while (true){
            i++;
            synchronized (queue){
                while (queue.size() == size){
                    System.out.println("队列满了");
                    try {
                        queue.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("生产者生产:queue+"+i);
                queue.add("queue");
                queue.notifyAll();
            }
        }
    }
}

消费者

public class Consumer implements Runnable{
    private Queue<String> queue;
    private  int size;

    public Consumer(Queue<String> queue, int size) {
        this.queue = queue;
        this.size = size;
    }
    @Override
    public void run() {
        while (true){
            synchronized (queue){
                while (queue.isEmpty()){
                    System.out.println("队列里面空了");
                    try {
                        queue.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                String remove = queue.remove();
                System.out.println("消费者消费了：queue"+remove);
            }
        }
    }
}

执行结果

生产者生产:queue+1
消费者消费了：queuequeue
生产者生产:queue+2
消费者消费了：queuequeue
生产者生产:queue+3
生产者生产:queue+4
生产者生产:queue+5
消费者消费了：queuequeue
生产者生产:queue+6
消费者消费了：queuequeue
生产者生产:queue+7
生产者生产:queue+8
消费者消费了：queuequeue
消费者消费了：queuequeue
生产者生产:queue+9
消费者消费了：queuequeue
消费者消费了：queuequeue
生产者生产:queue+10
消费者消费了：queuequeue
消费者消费了：queuequeue
队列里面空了