线程yield,start,run,join,sleep 傻傻分不清楚

古城微笑少年丶 2022-02-16 00:47 115阅读 0赞

**线程**:cpu调度的最小单位  
**进程**:操作系统分配资源的最小单位(线程共享进程内部的资源)

java 中提供了Thread 类,而这个类有几个方法

yield,start,run(来自接口runnable),sleep,

## **yield**: 欲罢能否? ##

告诉调度器自己当前可以让出资源(但是不一定有效)

A hint to the scheduler that the current thread is willing to yield
         * its current use of a processor. The scheduler is free to ignore this
         * hint.

## 测试代码: ##

(测试效果基本看不出)

Thread[] threads = new Thread[10];
            threads[0] = new Thread(() -> { 
                // ReadThreadLocal readThreadLocal2 = new ReadThreadLocal();
                //readThreadLocal2.begin();
                try { 
                    Thread.currentThread().sleep(500);
                } catch (InterruptedException e) { 
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName());
            });
            threads[0].setName("-1");
            threads[0].start();
            for (int i = 1; i < 10; i++) { 
                final Thread pre = threads[i - 1];
                final int index = i;
                threads[i] = new Thread(() -> { 
                    try { 
                        // 这里尝试1,2,号线程让出cpu
                        if (index < 3) { 
                            Thread.yield();
                        }
                        // 以下逻辑 可以保证 6,7,8,9 线程是有序执行
                        else if (index > 6) { 
                            pre.join();
                        }
                        // ReadThreadLocal readThreadLocal2 = new ReadThreadLocal();
                        // readThreadLocal2.begin();
                        Thread.sleep(500);
                        System.out.println(Thread.currentThread().getName());
                    } catch (InterruptedException e) { 
                        e.printStackTrace();
                    }
    
                });
                threads[i].setName(i + "");
                threads[i].start();
    
            }

效果:(这三次输出只是看到了join 接力棒的效果,始终保证6,7,8,9之间是严格有序的)  
第一次:

> \-1 1 3 2 5 4 6 7 8 9

第二次

> \-1 1 6 5 2 4 3 7 8 9

第三次

> \-1 3 1 4 2 6 5 7 8 9

## **start**:线程启动入口 ##

启动线程(线程进入就绪态:(也就是等待被cpu调度,并不是说先调用start,就先执行run方法)  
**run**: 线程真正的执行体,线程需要处理的业务逻辑全在这里

## **join**:接力棒 ##

join(othrerThread)

Waits for this thread to die// 等待到参数中的thread 死亡,自己才开始

(可以类比为线程进行接力赛,下一棒需要等上一棒到了才能开始跑),也就是可以达到有序执行的目的

### 代码测试 ###

看例子程序:

Thread[] threads = new Thread[10];
            threads[0] = new Thread(() -> { 
                
                try { 
                    Thread.sleep(500);
                } catch (InterruptedException e) { 
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() );
            });
            threads[0].setName("-1");
            threads[0].start();
            for (int i = 1; i < 10; i++) { 
                final Thread pre = threads[i - 1];
                threads[i] = new Thread(() -> { 
                    try { 
                        pre.join();
                       
                       
                        Thread.sleep(500);
                        System.out.println(Thread.currentThread().getName() );
                    } catch (InterruptedException e) { 
                        e.printStackTrace();
                    }
    
                });
                threads[i].setName(i + "");
                threads[i].start();
    
            }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2OTIyOTI3_size_16_color_FFFFFF_t_70]

## **sleep**: 抱锁入睡 ##

**注意不会丢失monitors,监视器,也就是不会释放锁**

> Causes the currently executing thread to sleep (temporarily cease  
> \* execution) for the specified number of milliseconds, subject to  
> \* the precision and accuracy of system timers and schedulers. The thread  
> \* does not lose ownership of any monitors.

### 代码测试: ###

线程1,线程2 都去获取同一个对象的monitor,各自都在**获取到之后输出 “sleep start”+id;sleep(500);输出"sleep end "+id**  
如果不释放锁的话,要么是线程1 连续输出两条,然后线程2连续输出两条  
否则是反过来  
代码使用10个线程

public class TestSleep { 
    
    
        public static void main(String[] args) { 
            final Object lock=new Object();
            for (int i=0;i<10;i++) { 
                Thread t=new Thread(()->{ 
                    synchronized (lock){ 
    
                        try { 
                            System.out.println("sleep start"+Thread.currentThread().getName());
                            Thread.sleep(500);
                            System.out.println("sleep end"+Thread.currentThread().getName());
                        } catch (InterruptedException e) { 
                            e.printStackTrace();
                        }
                    }
                });
                t.setName(i+"");
                t.start();
            }
        }
    
    }

### 效果: ###

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2OTIyOTI3_size_16_color_FFFFFF_t_70 1]

## **Object 的方法:wait VS notify** ##

**wait**:等待,会释放锁,将当前位置保存,暂停执行  
**norify**:唤醒,会释放锁,但是会将synchronized修饰代码块执行完之后才会释放

## 伪代码描述 ##

以下列伪代码为例:

第一块代码块
     synchonized(helloObject){ // 这里相当于是尝试获取对象helloObject 的锁
       输出:我是hello1
       helloObject.wait();
       输出:我是hello2
    }
    
    第二块代码块
    synchronized (helloObject){ 
    输出:我是word1:
    helloObject.notifyAll();
    输出:我是word2
    
    }

1.  假设上述代码:**线程1进入到第一块代码块,此时线程2阻塞到第二行代码块的synchronized 处**,**线程2没有获取到锁**
2.  线程**1**调用helloObject.wait();挂起线程,进入waiting 状态;// 已经输出 **hello1**
3.  线程**2**获取到helloObject 的锁, //输出**我是word1**
4.  线程**2**调用helloObject.notifyAll() //唤醒所有处于该对象的waiting 状态的线程
5.  线程**2**退出synchronized 同步块;//已输出 **我是word2**
6.  线程**2**释放helloObject 的monitor(看成锁)
7.  线程**1**继续// 输出**我是hello2**  
    以下附上**java并发编程艺术**中的一个例子:**等待-唤醒机制**

/** * @author wangwei * @date 2019/3/10 9:15 * @classDescription 场景:一个线程修改了一个对象的值,而另一个线程感觉到了变化,然后进行相应的操作 * 整个过程开始于一个线程,作用于另一个线程`,前者是生产者,后者是消费者 * <p> * 这种生产者消费者模式隔离了"做什么" 和"怎么做" * java 中的实现方式 * while(value!=desire){ * Thread.sleep(1000); * } * doSomething(); * <p> * 上述代码:在条件不满足时,sleep一段时间,避免过快的"无效尝试" * <p> * 存在的问题: * 1.难以确保及时性:睡眠时基本不占用处理器资源,但是如果睡眠过久,难以及时发现条件已经变化 * 2.难以降低开销:如果降低睡眠时间,消费者能及时发现条件变化,但是,却可能需要浪费更多的资源 * <p> * 两点矛盾,但是java内置了等待/通知机制,可以解决这个问题 */
    public class WaitNotify { 
        static boolean flag = true;
        static Object lock = new Object();
    
    
        public static void main(String[] args) throws InterruptedException { 
            Thread waitThread = new Thread(new Wait(), "WaitThread");
            waitThread.start();
            TimeUnit.SECONDS.sleep(1);
            Thread notifyThread = new Thread(new Notify(), "NotifyThread");
            notifyThread.start();
        }
    
        static class Wait implements Runnable { 
    
            @Override
            public void run() { 
                synchronized (lock) { 
                    // 当条件不满足时,继续wait,但是会释放锁lock
                    while (flag) { 
                        try { 
                            System.out.println(Thread.currentThread() + " flag is true,wait @ "
                                    + new SimpleDateFormat("HH:mm:ss").format(new Date()));
                            lock.wait();
                        } catch (InterruptedException e) { 
                            e.printStackTrace();
                        }
                    }
    
                    //条件满足时,完成工作
                    System.out.println(Thread.currentThread() + " flag is false,running@ "
                            + new SimpleDateFormat("HH:mm:ss").format(new Date()));
    
                }
    
            }
        }
    
    
        static class Notify implements Runnable { 
    
            @Override
            public void run() { 
                //加锁,拥有lock 的monitor
                synchronized (lock) { 
                    // 获取lock锁,然后进行通知(不会释放锁)
                    // 直到当前线程释放lock锁之后,WaitThread 才能在wait方法上返回
                    System.out.println(Thread.currentThread() + " hold lock ,notify @ "
                            + new SimpleDateFormat("HH:mm:ss").format(new Date()));
                    lock.notifyAll();
                    flag = false;
                    SleepUtil.second(5);
    
                }
                // 再次加锁
                synchronized (lock) { 
                    System.out.println(Thread.currentThread() + " hold lock again ,sleep @ "
                            + new SimpleDateFormat("HH:mm:ss").format(new Date()));
                    SleepUtil.second(5);
                }
            }
        }
    }

输出:  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2OTIyOTI3_size_16_color_FFFFFF_t_70 2]

# 等待唤醒机制应用–线程池 #

奉上**并发编程艺术**一书中简易web服务器  
可前往github 获取  
[https://github.com/TopForethought/java/tree/master/src/top/forethought/concurrency/threads/httpserver][https_github.com_TopForethought_java_tree_master_src_top_forethought_concurrency_threads_httpserver]  
这里就不再粘贴代码了

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2OTIyOTI3_size_16_color_FFFFFF_t_70]: /images/20220216/b8cdd252a4d74d97885a020ff2b72bb9.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2OTIyOTI3_size_16_color_FFFFFF_t_70 1]: /images/20220216/899812ad8fc44346b6e00e7f1a8b7e5f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2OTIyOTI3_size_16_color_FFFFFF_t_70 2]: /images/20220216/8d5d24ec04f945df9351e3ab059ed616.png
[https_github.com_TopForethought_java_tree_master_src_top_forethought_concurrency_threads_httpserver]: https://github.com/TopForethought/java/tree/master/src/top/forethought/concurrency/threads/httpserver