关于多线程

本文介绍了一个使用Java实现的多线程程序案例,通过两个线程分别对共享变量进行加1和减1操作,并利用synchronized关键字和wait/notify方法确保线程安全及变量值在0到1之间交替。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

题目:请编写一个多线程程序,实现两个线程,其中一个线程完成对某个对象的int成员变量的增加操作,即每次加1,另一个线程完成对该对象的成员变量的减操作,即每次减1,同时要保证该变量的值不会小于0,不会大于1,该变量的初始值为0.

即要求输出结果是0101010101010101这样的形式

关于wait,notify,notifyAll以及sleep方法的关系(重点)

1 如果一个线程调用了某个对象的wait方法,那么该线程首先必须要有该对象的锁(换句话说,一个线程调用了某个对象的wait方法,你们该wait方法必须要在synchronized中)

2 如果一个线程调用了某个对象的wait方法,那么该线程就会释放该对象的锁

3 在java对象中,有两种池(锁池,等待池)

4 如果一个线程调用了某个对象的wait方法,那么该线程进入该对象的等待池中(释放锁),如果未来的某一时刻,另外一个线程调用了相同的对象的notify或notifyall方法,那么在该等待池中的等待的线程就会起来进入该对象的锁池中,去等待获得该对象的锁,如果获得锁成功后,那么该线程将继续沿着wait方法之后的路径去执行。

5 sleep(long time),如果一个线程调用了sleep方法睡眠,那么在睡眠的同时,它不会失去对象的锁的拥有权。

 

关于synchronized关键字的作用

1 在某个对象的所有synchronized方法中,在某一时刻,只能有一个唯一的一个线程去访问这些synchronized方法

2 如果一个方法是synchronized方法,那么该synchronized关键字表示给当前对象上锁(即this)

3 如果一个synchronized方法是静态的(static的),那么该synchronized关键字表示给当前对象所对应的Class对象上锁。(每个类,不管生成多少对象,其Class对象只有一个)

 

代码示例一、

java 代码
  1. package com.test.thread;   
  2.   
  3. public class Sample {   
  4.     private int number;   
  5.        
  6.        
  7.     public synchronized void increate()   
  8.     {   
  9.         while(number>0)   
  10.         {   
  11.             try {   
  12.                 wait();   
  13.             } catch (InterruptedException e) {   
  14.                 e.printStackTrace();   
  15.             }   
  16.         }   
  17.         number++;   
  18.         System.out.println(number);   
  19.         notify();   
  20.     }   
  21.        
  22.        
  23.     public synchronized void decreate()   
  24.     {   
  25.         while(number==0)   
  26.         {   
  27.             try {   
  28.                 wait();   
  29.             } catch (InterruptedException e) {   
  30.                 e.printStackTrace();   
  31.             }   
  32.         }   
  33.         number--;   
  34.         System.out.println(number);   
  35.         notify();   
  36.     }   
  37.        
  38.        
  39. }   

 

java 代码
  1. package com.test.thread;   
  2.   
  3. public class IncreateThread extends Thread {   
  4.   
  5.     private Sample sample;   
  6.        
  7.     public IncreateThread(Sample sample)   
  8.     {   
  9.         this.sample = sample;   
  10.     }   
  11.        
  12.        
  13.     @Override  
  14.     public void run() {   
  15.            
  16.         for(int i=0;i<5;i++)   
  17.         {   
  18.             try {   
  19.                 Thread.sleep(1000);   
  20.             } catch (InterruptedException e) {   
  21.                 e.printStackTrace();   
  22.             }   
  23.                
  24.             sample.increate();             
  25.         }   
  26.            
  27.     }   
  28.   
  29. }   

 

java 代码
  1. package com.test.thread;   
  2.   
  3. public class DecreateThread extends Thread {   
  4.   
  5.     private Sample sample;   
  6.        
  7.     public DecreateThread(Sample sample)   
  8.     {   
  9.         this.sample = sample;   
  10.     }   
  11.        
  12.        
  13.     @Override  
  14.     public void run() {   
  15.            
  16.         for(int i=0;i<5;i++)   
  17.         {   
  18.             try {   
  19.                 sleep(1000);   
  20.             } catch (InterruptedException e) {   
  21.                 e.printStackTrace();   
  22.             }   
  23.                
  24.             sample.decreate();   
  25.                
  26.         }   
  27.            
  28.            
  29.     }   
  30.   
  31. }   

 

java 代码
  1. package com.test.thread;   
  2.   
  3. public class TestThread {   
  4.   
  5.     /**  
  6.      * @param args  
  7.      */  
  8.     public static void main(String[] args) {   
  9.            
  10.         Sample sample = new Sample();   
  11.            
  12.         Thread thread1 = new IncreateThread(sample);   
  13.         Thread thread2 = new DecreateThread(sample);   
  14.            
  15.         Thread thread3 = new IncreateThread(sample);   
  16.         Thread thread4 = new DecreateThread(sample);   
  17.            
  18.         thread1.start();   
  19.         thread2.start();   
  20.         thread3.start();   
  21.         thread4.start();   
  22.   
  23.     }   
  24.   
  25. }
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值