wait方法 与 notify/notifyAll方法

最新推荐文章于 2024-05-01 19:10:24 发布
最新推荐文章于 2024-05-01 19:10:24 发布
阅读量258 收藏 1
点赞数
分类专栏： java 文章标签： java wait notify notifyAll
原文链接：https://mp.csdn.net/mp_blog/creation/editor?spm=1001.2014.3001.5352
版权

1. 线程状态图

 

这是线程的7状态模型图，常见的7大状态之间的转换关系也在上面。
多线程之间的通信主要用到4个方法，wait（）、wait（long time）、notify（）、notifyAll（）。

  1. wait（）：作用是使当前线程从调用处中断并且释放锁转入等待队列，直到收到notify或者notifyAll的通知才能从等待队列转入锁池队列，没有收到停止会一直死等。

  2. wait（long time）：相比wait多了一个等待的时间time，如果经过time(毫秒)时间后没有收到notify或者notifyAll的通知，自动从等待队列转入锁池队列。

  3. notify（）：随机从等待队列中通知一个持有相同锁的一个线程，如果没有持有相同锁的wait线程那么指令忽略无效。注意是持有相同锁，并且是随机没有固定的，顺序这一点在生产者消费者模型中很重要，会造成假死的状态。

  4. notifyAll（）：通知等待队列中的持有相同锁的所有线程，让这些线程转入锁池队列。如果没有持有相同锁的wait线程那么指令忽略无效。

  5. wait的两个方法都需要注意中断的问题，wait中断是从语句处中断并且释放锁，当再次获得锁时是从中断处继续向下执行。

  6. notify 和 notifyAll方法通知是延迟通知，必须等待当前线程体执行完所有的同步方法/代码块中的语句退出释放锁才通知wait线程。

  7. 这四个方法都必须在获得锁的情况下才能调用，否则会出现非法监视状态异常。

2. 基本使用

2.1、wait立即释放锁 与 notify/notifyAll延迟通知

package com.study;

import java.time.LocalDateTime;

/**
 * wait与notify/notifyAll延迟通知
 */
public class Demo {
    public static void main(String[] args) throws Exception {
        MyService myService = new MyService();
        WaitThread waitThread = new WaitThread("WaitThread", myService);
        waitThread.start();


        Thread.sleep(1000);
        NotifyThread notifyThread = new NotifyThread("NotifyThread", myService);
        notifyThread.start();
    }
}

class MyService {
    private Object obj = new Object();

    public void waitfun() {
        try {
            synchronized (obj) {
                System.out.println("begin   wait: " + Thread.currentThread().getName() + " " + LocalDateTime.now());
                obj.wait();
                System.out.println("end     wait: " + Thread.currentThread().getName() + " " + LocalDateTime.now());
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public void notifyfun() {
        try {
            synchronized (obj) {
                System.out.println("begin notify: " + Thread.currentThread().getName() + " " + LocalDateTime.now());
                obj.notify();
                System.out.println("end   notity: " + Thread.currentThread().getName() + " " + LocalDateTime.now());
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

class WaitThread extends Thread {
    private MyService myService;

    public WaitThread(String name, MyService myService) {
        super(name);
        this.myService = myService;
    }

    @Override
    public void run() {
        myService.waitfun();
    }
}

class NotifyThread extends Thread {
    private MyService myService;

    public NotifyThread(String name, MyService myService) {
        super(name);
        this.myService = myService;
    }

    @Override
    public void run() {
        myService.notifyfun();
    }
}

 

 分析：
WaitThread线程要先获得对象锁，才能进入代码块，然后调用wait方法进行中断(类似阻塞等待)，并立即释放对象锁；
main线程睡眠1000ms后，
NotifyThread线程要先获得对象锁，才能进入代码块，然后调用执行notify通知方法，这个时候上面的wait方法并不会立即往下执行，因为这个时候上面的WaitThread线程还没有获得对象锁，
等NotifyThread线程执行完代码块释放锁后，WaitThread线程获得对象锁后，wait方法不再阻塞，继续往下执行。
执行完了NotifyThread线程 同步方法/代码块里的所有语句 才进行通知，WaitThread线程收到通知进行执行，从中断处继续向下执行最后得到上图结果。

 

2.2、wait(long time)的自动唤醒

package com.study;

import java.time.LocalDateTime;

/**
 * wait与notify/notifyAll延迟通知
 */
public class Demo {
    public static void main(String[] args) throws Exception {
        MyService myService = new MyService();
        WaitThread waitThread = new WaitThread("WaitThread", myService);
        waitThread.start();


        Thread.sleep(1000);
        NotifyThread notifyThread = new NotifyThread("NotifyThread", myService);
        notifyThread.start();
    }
}

class MyService {
    private Object obj = new Object();

    public void waitfun() {
        try {
            synchronized (MyService.class) {
                System.out.println("begin   wait: " + Thread.currentThread().getName() + " " + LocalDateTime.now());
                MyService.class.wait(5000);
                System.out.println("end     wait: " + Thread.currentThread().getName() + " " + LocalDateTime.now());
            }
            System.out.println(Thread.currentThread().getName()+"等待5000ms后自动唤醒!");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public void notifyfun() {
        try {
            synchronized (MyService.class) {
                System.out.println("begin notify: " + Thread.currentThread().getName() + " " + LocalDateTime.now());
                // MyService.class.notify();
                System.out.println("end   notity: " + Thread.currentThread().getName() + " " + LocalDateTime.now());
                Thread.sleep(10000);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

class WaitThread extends Thread {
    private MyService myService;

    public WaitThread(String name, MyService myService) {
        super(name);
        this.myService = myService;
    }

    @Override
    public void run() {
        myService.waitfun();
    }
}

class NotifyThread extends Thread {
    private MyService myService;

    public NotifyThread(String name, MyService myService) {
        super(name);
        this.myService = myService;
    }

    @Override
    public void run() {
        myService.notifyfun();
    }
}

 

 方法主体中并没有对wait的线程进行唤醒停止，但是经过time秒后WaitThread线程自动唤醒了。wait(long time)方法在经过time（毫秒）之后的等待即使没有收到 通知 会自动从等待队列转入锁池队列，由于NotifyThread线程10秒后才执行完代码块才释放锁，虽然WaitThread在5秒后就有竞争锁的资格，但是获得锁是在10秒后，所以10秒后wait(long time)方法才唤醒，往下继续执行。

2.3、提前唤醒

处于wait（long time）的线程如果正处在time等待的时间内提前收到通知会直接进入锁池队列，time时间提前失效。

package com.study;

import java.time.LocalDateTime;

/**
 * wait与notify/notifyAll延迟通知
 */
public class Demo {
    public static void main(String[] args) throws Exception {
        MyService myService = new MyService();
        WaitThread waitThread = new WaitThread("WaitThread", myService);
        waitThread.start();


        Thread.sleep(1000);
        NotifyThread notifyThread = new NotifyThread("NotifyThread", myService);
        notifyThread.start();
    }
}

class MyService {
    private Object obj = new Object();

    public void waitfun() {
        try {
            synchronized (MyService.class) {
                System.out.println("begin   wait: " + Thread.currentThread().getName() + " " + LocalDateTime.now());
                MyService.class.wait(8000);
                System.out.println("end     wait: " + Thread.currentThread().getName() + " " + LocalDateTime.now());
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public void notifyfun() {
        try {
            synchronized (MyService.class) {
                System.out.println("begin notify: " + Thread.currentThread().getName() + " " + LocalDateTime.now());
                MyService.class.notify();
                System.out.println("end   notity: " + Thread.currentThread().getName() + " " + LocalDateTime.now());
                Thread.sleep(1000);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

class WaitThread extends Thread {
    private MyService myService;

    public WaitThread(String name, MyService myService) {
        super(name);
        this.myService = myService;
    }

    @Override
    public void run() {
        myService.waitfun();
    }
}

class NotifyThread extends Thread {
    private MyService myService;

    public NotifyThread(String name, MyService myService) {
        super(name);
        this.myService = myService;
    }

    @Override
    public void run() {
        myService.notifyfun();
    }
}


 

 虽然wait(8000);在8秒后才会自动唤醒，但是notify可以提前唤醒，只要竞争到锁，wait(8000)方法立即往下继续执行。
 

2.5、单一通知
 

notify方法随机的从等待队列中唤醒一个持有相同锁的线程进入锁池队列争抢同步锁，如果没有持有相同锁的wait的线程则notify指令无效。
 

package com.study;

import java.time.LocalDateTime;

/**
 * wait与notify/notifyAll延迟通知
 */
public class Demo {
    public static void main(String[] args) throws Exception {
        MyService myService = new MyService();
        for (int i = 1; i <= 5; i++) {
            new WaitThread("WaitThread" + i, myService).start();
        }


        Thread.sleep(1000);
        for (int i = 6; i <= 10; i++) {
            new NotifyThread("NotifyThread" + i, myService).start();
        }

    }
}

class MyService {
    private Object obj = new Object();
    private Object obj2 = new Object();

    public void waitfun() {
        try {
            synchronized (obj) {
                System.out.println("begin   wait: " + Thread.currentThread().getName() + " " + LocalDateTime.now());
                obj.wait();
                System.out.println("end     wait: " + Thread.currentThread().getName() + " " + LocalDateTime.now());
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public void notifyfun() {
        try {
            // 0 ≤ Math.random() < 1
            if (Math.random() < 0.7) {//70%的概率
                synchronized (obj) {
                    System.out.println("begin notify: " + Thread.currentThread().getName() + " " + LocalDateTime.now());
                    obj.notify();
                    System.out.println("end   notity: " + Thread.currentThread().getName() + " " + LocalDateTime.now());
                    Thread.sleep(1000);
                }
            }else{
                synchronized (obj2) {
                    System.out.println("不同锁begin notify: " + Thread.currentThread().getName() + " " + LocalDateTime.now());
                    obj2.notify();
                    System.out.println("不同锁end   notity: " + Thread.currentThread().getName() + " " + LocalDateTime.now());
                    Thread.sleep(1000);
                }
            }

        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

class WaitThread extends Thread {
    private MyService myService;

    public WaitThread(String name, MyService myService) {
        super(name);
        this.myService = myService;
    }

    @Override
    public void run() {
        myService.waitfun();
    }
}

class NotifyThread extends Thread {
    private MyService myService;

    public NotifyThread(String name, MyService myService) {
        super(name);
        this.myService = myService;
    }

    @Override
    public void run() {
        myService.notifyfun();
    }
}


 

 

  有5个线程都在wait等待，有5个notify但是有70%概率才使用同一个对象锁obj，上面允许结果有2个wai不能正常获得锁，所以程序不会结束一直阻塞在那里。
 

 

2.6、全部通知
 

notifyAll方法将等待队列中所有的持有相同锁的线程唤醒进入锁池队列争抢同步锁。
 

package com.study;

import java.time.LocalDateTime;

/**
 * wait与notify/notifyAll延迟通知
 */
public class Demo {
    public static void main(String[] args) throws Exception {
        MyService myService = new MyService();
        for (int i = 1; i <= 5; i++) {
            new WaitThread("WaitThread" + i, myService).start();
        }


        Thread.sleep(1000);
        new NotifyThread("NotifyThread", myService).start();
    }
}

class MyService {
    private Object obj = new Object();

    public void waitfun() {
        try {
            synchronized (obj) {
                System.out.println("begin   wait: " + Thread.currentThread().getName() + " " + LocalDateTime.now());
                obj.wait();
                System.out.println("end     wait: " + Thread.currentThread().getName() + " " + LocalDateTime.now());
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public void notifyfun() {
        try {
            synchronized (obj) {
                System.out.println("begin notify: " + Thread.currentThread().getName() + " " + LocalDateTime.now());
                obj.notifyAll();
                System.out.println("end   notity: " + Thread.currentThread().getName() + " " + LocalDateTime.now());
                Thread.sleep(1000);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

class WaitThread extends Thread {
    private MyService myService;

    public WaitThread(String name, MyService myService) {
        super(name);
        this.myService = myService;
    }

    @Override
    public void run() {
        myService.waitfun();
    }
}

class NotifyThread extends Thread {
    private MyService myService;

    public NotifyThread(String name, MyService myService) {
        super(name);
        this.myService = myService;
    }

    @Override
    public void run() {
        myService.notifyfun();
    }
}


 

 

 
 

3. 异常释放锁
 

学习synchronized时，有几种情况当同步方法 / 块中遇到异常会提前结束线程体。
 

  •  
    sleep + interrupt：这两个方法没有先后顺序，无论哪个先执行，发生异常时线程体提前中止。
     
  •  
    手动制造异常：当执行到某个程度的时候，如果想提前结束直接利用throw new Exception()。
     
  •  
    使用stop方法直接摧毁线程，这个方法已经废弃了不推荐使用。
     
  •  
    使用return 提前结束线程体的运行，但是这种方法并不是异常。
     
 

3.1、手动制造异常提前终止
 

 public void notifyMethod(){
        try{
            synchronized (obj){
                for(int i = 1;i <= 10;i++){
                    if(i==0){
                        obj.notify();
                        throw new Exception();		//制造异常
                    }
                }
            }
        }catch (Exception e){
         //   e.printStackTrace();
        }
    }
 

3.2、wait + interrupt方法提前终止线程
 

package com.study;

import java.time.LocalDateTime;

/**
 * wait与notify/notifyAll延迟通知
 */
public class Demo {
    public static void main(String[] args) throws Exception {
        MyService myService = new MyService();
        WaitThread waitThread = new WaitThread("WaitThread", myService);
        waitThread.start();

        Thread.sleep(5000);
        waitThread.interrupt();
    }
}

class MyService {
    private Object obj = new Object();

    public void waitfun() {
        synchronized (obj) {
            System.out.println("begin   wait: " + Thread.currentThread().getName() + " " + LocalDateTime.now());
            try {
                obj.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("end     wait: " + Thread.currentThread().getName() + " " + LocalDateTime.now());
        }
    }
}

class WaitThread extends Thread {
    private MyService myService;

    public WaitThread(String name, MyService myService) {
        super(name);
        this.myService = myService;
    }

    @Override
    public void run() {
        myService.waitfun();
    }
}



 

 

 interrupt()方法，会使wait()方法抛出InterruptedException异常。
  interrupt()方法，也会使Thread.sleep()方法抛出InterruptedException异常。
 

public void waitfun() {
        synchronized (obj) {
            System.out.println("begin   wait: " + Thread.currentThread().getName() + " " + LocalDateTime.now());
            try {
                // obj.wait();
                Thread.sleep(60000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("end     wait: " + Thread.currentThread().getName() + " " + LocalDateTime.now());
        }
    }
 

 

4. 总结
 

  1.  
    sleep睡眠是抱锁睡眠（不会释放锁），不会进入等待队列而是进入阻塞状态。如上图
     
  2.  
    wait（）方法会立即中断(类似阻塞等待)，并释放锁，进入等待队列。唤醒后仍然需要去争抢获得同步锁才能继续从中断处向下执行。
     
  3.  
    wait（long time）方法会在time毫秒后自动唤醒，如果提前遇到通知会提前进入等待队列。
     
  4.  
    notify / notifyAll 通知是随机顺序通知的，并没有固定的顺序进行通知具体的某个线程。并且只通知持有相同锁的wait线程。
     
  5.  
    灵活使用异常能够帮助线程体的提前终止。
     
 

参考：
 

wait方法 与 notify方法_wait和notify_Splaying的博客-CSDN博客

                

        

        

    




    

      

        

            

              
                
                  小百菜
                
              
            

            

                关注
              
            

        

        

          
    
            
  • 
              
                
                
                
                
                      0
                
              
              
    点赞
    
            
    • 
            
  • 
              
                
                
                
              
              
    踩
    
            
    • 
            
  • 
              
                
                
                
                
                    1
                
              
              
    
                
    
                  
                    收藏
                  
                
    
              
    
              
    
                
    
                  觉得还不错?
                  
                    一键收藏
                  
                 
                
    
              
    
            
    • 
          
  • 
            
    
              
              
            
    
              
              
              
                    0
              
            
            
    评论
    
          
    • 
          
  • 
          
    • 
          
  • 
            
              
            
              
    
            
              
                
            
    
          
    • 
        

      

      

            

                专栏目录
          










                



	

		

			

				
					
Java 同步方式 wait和notify/notifyall

				
			

			

				

					06-24
				

			

		

		

			
				
Java 同步方式 wait和notify/notifyall

			
		

	



                

              
                



	

		

			

				
					
wait、notify、notifyAll介绍

				
			

			

				

					刘运召的博客
				

				

					05-05
					
					718
					
				

			

		

		

			
				
wait：在其他线程调用此对象的 notify() 方法或 notifyAll() 方法前，导致当前线程等待wait(long timeout)： 在其他线程调用此对象的 notify() 方法或 notifyAll() 方法，或者超过指定的时间量前，导致当前线程等待
notify：唤醒在此对象监视器上等待的单个线程（如果导致死锁）
notifyAll：唤醒在此对象监视器上等待的所有线程

			
		

	



                


  
              

                


	

		

			

				
					
线程通讯（wait方法、notify方法、notifyAll方法）

				
			

			

				

					m0_48273471的博客
				

				

					04-03
					
					2062
					
				

			

		

		

			
				
wait方法，notify方法，notifyAll方法的使用及注意事项

			
		

	





	

		

			

				
					
Java多线程：wait()和notify()/notifyAll()

				
			

			

				

					qq_38470315的博客
				

				

					04-06
					
					1514
					
				

			

		

		

			
				
notify()的作用是，如果有多个线程等待，那么线程规划器随机挑选出一个wait的线程，对其发出通知notify()，并使它等待获取该对象的对象锁。注意"等待获取该对象的对象锁"，这意味着，即使收到了通知，wait的线程也不会马上获取对象锁，必须等待notify()方法的线程释放锁才可以。和wait()一样，notify()也要在同步方法/同步代码块中调用。当然，唤醒的顺序不重要，因为notifyAll()把处于同一资源下wait的线程全部唤醒，至于唤醒的顺序，就和线程启动的顺序一样，是虚拟机随机的。

			
		

	



		

			
		



	

		

			

				
					
wait、notify、notifyAll的理解与使用

				
			

			

				

					lizhengze1117的博客
				

				

					05-26
					
					5916
					
				

			

		

		

			
				
目录基础知识waitnotifynotifyAllwait()与notify()操作会释放锁吗？wait/notify 消息通知潜在的一些问题总结：生产者-消费者模型的实现
基础知识
Java 中，可以通过配合调用 Object 对象的 wait() 方法和 notify() 方法或 notifyAll() 方法来实现线程间的通信。
在线程中调用 wait() 方法，将阻塞当前线程，直至等到其他线程调用了调用 notify() 方法或 notifyAll() 方法进行通知之后，当前线程才能从 wait() 

			
		

	





	

		

			

				
					
wait,notify,notifyAll原理以及实际使用场景

				
			

			

				

					Zero .
				

				

					08-30
					
					929
					
				

			

		

		

			
				
wait，notify，notifyAll  实际使用场景

			
		

	





	

		

			

				
					
线程之间的通信—wait()、notify()、notifyAll()

				
			

			

				

					qq_45036591的博客
				

				

					11-23
					
					895
					
				

			

		

		

			
				
wait()和notify()是进行线程间通讯的两个重要的方法。
1.wait()的作用是让当前线程进入等待状态，同时，wait()也会让当前线程释放它所持有的锁。“直到其他线程调用此对象的 notify() 方法或 notifyAll() 方法”，当前线程被唤醒(进入“就绪状态”)
2.notify()和notifyAll()的作用，则是唤醒当前对象上的等待线程；notify()是唤醒单个线程，...

			
		

	





	

		

			

				
					
【多线程】wait 、notify 和 notifyAll 讲解

				
			

			

				

					Gmerrysong 的博客
				

				

					09-10
					
					338
					
				

			

		

		

			
				
wait 、notify 和 notifyAll 讲解

			
		

	





	

		

			

				
					
Java多线程中wait、notify、notifyAll使用详解

				
			

			

				

					08-26
				

			

		

		

			
				
主要介绍了Java多线程中wait、notify、notifyAll使用详解，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧

			
		

	





	

		

			

				
					
Java 中Object的wait() notify() notifyAll()方法使用

				
			

			

				

					08-30
				

			

		

		

			
				
主要介绍了Java 中Object的wait() notify() notifyAll()方法使用的相关资料,需要的朋友可以参考下

			
		

	





	

		

			

				
					
如何在Java中正确使用 wait, notify 和 notifyAll

				
			

			

				

					12-22
				

			

		

		

			
				
wait， notify 和 notifyAll，这些在多线程中被经常用到的保留关键字，在实际开发的时候很多时候却并没有被大家重视。本文对这些关键字的使用进行了描述。 	　在 Java 中可以用 wait、notify 和 notifyAll 来实现...

			
		

	





	

		

			

				
					
【并发编程】 — 线程间的通信wait、notify、notifyAll

				
			

			

				

					12-21
				

			

		

		

			
				
文章目录1 wait、notify、notifyAll简单介绍1.1 使用方法 + 为什么不是Thread类的方法1.2 什么时候加锁、什么时候释放锁？1.3 notify、notifyAll的区别2 两个比较经典的使用案例2.1 案例1 — ABCABC。。。三个线程...

			
		

	





	

		

			

				
					
wait(),notify()和notifyAll()

				
			

			

				

					weixin_44731875的博客
				

				

					08-05
					
					209
					
				

			

		

		

			
				
其实wait()方法就是使线程停止运行。

方法wait()的作用是使当前执行代码的线程进行等待，wait()方法是Object类的方法，该方法是用来将当前线程置入“预执行队列”中，并且在wait()所在的代码处停止执行，直到接到通知或被中断为止。
wait()方法只能在同步方法中或同步块中调用。如果调用wait()时，没有持有适当的锁，会抛出异常。
wait()方法执行后，当前线程释放锁，线程与其它线程竞争重新获取锁
notify方法就是使停止的线程继续运行。
1 方法notify()也要在同步方法或同步

			
		

	





	

		

			

				
					
C++11 条件变量

				
			

			

				

					kakaka666的博客
				

				

					11-18
					
					1048
					
				

			

		

		

			
				
C++11 条件变量

			
		

	





	

		

			

				
					
C++11条件变量：wait(lock),notify_one()与notify_all()

				
			

			

				

					$好记性还是要多记录$
				

				

					01-15
					
					1925
					
				

			

		

		

			
				
linux,C++11,wait ,notify

			
		

	





	

		

			

				
					
高并发编程：9、wait、notify、notifyAll（二 程序假死的原因分析）

				
			

			

				

					oJueQiang123456的博客
				

				

					07-25
					
					350
					
				

			

		

		

			
				
一、概述

多个生产者和多个消费者同时存在时导致出现程序假死的原因分析。
二、代码


public class Thread11 {
	
    private Integer index = 0;
    private volatile boolean isProducer = false;
    private Object LOCK = new Object();
    public...

			
		

	





	

		

			

				
					
Java多线程学习之wait、notify/notifyAll 详解与生产者和消费者问题

				
			

			

				

					zehuawong的博客
				

				

					09-28
					
					704
					
				

			

		

		

			
				
转载 https://www.cnblogs.com/moongeek/p/7631447.html
1、wait()、notify/notifyAll() 方法是Object的本地final方法，无法被重写。
2、wait()使当前线程阻塞，前提是 必须先获得锁，一般配合synchronized 关键字使用，即，一般在synchronized 同步代码块里使用 wait()、notify/not...

			
		

	





	

		

			

				
					
notify()方法、notifyAll()方法和wait()方法 详解

				
			

			

				

					夜冬的博客
				

				

					10-31
					
					4905
					
				

			

		

		

			
				
线程作为程序内部的多个执行流，相互之间是可以通讯的。线程间通讯可以通过多种方式来进行，例如：线程间可以共享变量来进行通讯，使每个线程根据共享变量的值进行操作和运算，当通过共享变量进行通讯时，通常需要引入同步控制，
 线程间也可以通过 wati()、notify()和notifyAll()等方法进行通讯。
 每一个类的对象的实例都有一个等待集合，当在该实例上调用wait()方法后，线程都...

			
		

	





	

		

			

				
					
C#(C Sharp)学习笔记_类【十五】

					
最新发布

				
			

			

				

					追求细节，成就完美
				

				

					05-01
					
					367
					
				

			

		

		

			
				
类（Class）是面向对象程序设计（OOP，Object-Oriented Programming）实现信息封装的基础。类是一种用户定义的引用数据类型，也称类类型。每个类包含数据说明和一组操作数据或传递消息的函数。类的实例称为对象。

			
		

	





	

		

			

				
					
为什么线程通信方法wait|notify|notifyAll必须在同步方法|同步块中被调用

				
			

			

				

					07-28
				

			

		

		

			
				
线程通信方法wait、notify和notifyAll必须在同步方法或同步块中被调用，是因为这些方法涉及到线程的等待与唤醒操作，而等待与唤醒必须在共享资源的保护下进行，以避免竞态条件（race condition）和数据不一致的问题...

			
		

	



              



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

  

      
    
          
  • 
              
    
                  
                  
              
    
              
    非常没帮助
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    没帮助
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    一般
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    有帮助
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    非常有帮助
    
          
    • 
      

      

      

          
          提交
      

      

  




          




        



    





    



      

      

        
      

      





	

		评论	
	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

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

              

            

          

      

      余额充值