实现多线程的几种方式

阳光穿透心脏的1/2处 2022-05-21 06:17 184阅读 0赞

# 多线程概述 #

多线程可以用如下方法实现：  
一、同步方法  
　　即有synchronized关键字修饰的方法。 由于java的每个对象都有一个内置锁，当用此关键字修饰方法时， 内置锁会保护整个方法。在调用该方法前，需要获得内置锁，否则就处于阻塞状态。  
注： synchronized关键字也可以修饰静态方法，此时如果调用该静态方法，将会锁住整个类。

二、同步代码块  
　　即有synchronized关键字修饰的语句块。 被该关键字修饰的语句块会自动被加上内置锁，从而实现同步

这两个部分可以用如下博客介绍，本文不多说  
[Java学习笔记—多线程同步的五种方法][Java]

三、wait与notify（补充）  
wait():使一个线程处于等待状态，并且释放所持有的对象的lock。

sleep():使一个正在运行的线程处于睡眠状态，是一个静态方法，调用此方法要捕捉InterruptedException异常。  
notify():唤醒一个处于等待状态的线程，注意的是在调用此方法的时候，并不能确切的唤醒某一个等待状态的线程，而是由JVM确定唤醒哪个线程，而且不是按优先级。  
Allnotity():唤醒所有处入等待状态的线程，注意并不是给所有唤醒线程一个对象的锁，而是让它们竞争。

package com.dlut.jeremy.conccurrency;
    
    import java.text.DateFormat;
    import java.text.SimpleDateFormat;
    import java.util.Date;
    
    public class WaitNotifyThread {
        
    
        //条件是否满足的标志
        private static boolean flag = true;
        //对象的监视器锁
        private static Object lock = new Object();
        //日期格式化器
        private static DateFormat format = new SimpleDateFormat("HH:mm:ss");
    
        public static void main(String[] args){
            Thread waitThread = new Thread(new WaitThread(),"WaitThread");
            waitThread.start();
            Thread notifyThread = new Thread(new NotifyThread(),"NotifyThread");
            notifyThread.start();
        }
    
        /**
         * 等待线程
         */
        private static class WaitThread implements Runnable{
        
            public void run() {
                //加锁，持有对象的监视器锁
                synchronized (lock){
                    //只有成功获取对象的监视器才能进入这里
                    //当条件不满足的时候，继续wait，直到某个线程执行了通知
                    //并且释放了lock的监视器（简单来说就是锁）才能从wait
                    //方法返回
                    while (flag){
                        try {
                            System.out.println(Thread.currentThread().getName() + " flag is true,waiting at "
                                    + format.format(new Date()));
                            lock.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                    //条件满足，继续工作
                    System.out.println(Thread.currentThread().getName() + " flag is false,running at "
                            + format.format(new Date()));
                }
            }
        }
    
        /**
         * 通知线程
         */
        private static class NotifyThread implements Runnable{
        
            public void run() {
                synchronized (lock){
                    //获取lock锁，然后执行通知，通知的时候不会释放lock锁
                    //只有当前线程退出了lock后，waitThread才有可能从wait返回
                    System.out.println(Thread.currentThread().getName() + " holds lock. Notify waitThread at "
                            + format.format(new Date()));
                    lock.notifyAll();
                    flag = false;
                }
                //再次加锁
                synchronized (lock){
                    System.out.println(Thread.currentThread().getName() + " holds lock again. NotifyThread will sleep at "
                            + format.format(new Date()));
                }
            }
        }
    }

运行结果：

WaitThread flag is true,waiting at 22:49:41
    NotifyThread holds lock. Notify waitThread at 22:49:41
    NotifyThread holds lock again. NotifyThread will sleep at 22:49:41
    WaitThread flag is false,running at 22:49:41

--------------------

[Java]: https://blog.csdn.net/wenwen091100304/article/details/48318699