Java多线程的常见例子

电玩女神 2022-05-24 11:11 193阅读 0赞

一.相关知识：

Java多线程程序设计到的知识：

（一）对同一个数量进行操作

（二）对同一个对象进行操作

（三）回调方法使用

（四）线程同步，死锁问题

（五）线程通信

二．示例一：三个售票窗口同时出售20张票;

程序分析：1.票数要使用同一个静态值

2.为保证不会出现卖出同一个票数，要java多线程同步锁。

设计思路：1.创建一个站台类Station，继承Thread，重写run方法，在run方法里面执行售票操作！售票要使用同步锁：即有一个站台卖这张票时，其他站台要等这张票卖完！

2.创建主方法调用类

（一）创建一个站台类，继承Thread

\[plain\]  [view plain][]   [copy][view plain]

1.  package com.xykj.threadStation;  
2.     
3.  public class Station extends Thread \{  
4.     
5.          // 通过构造方法给线程名字赋值  
6.          public Station(String name) \{  
7.               super(name);// 给线程名字赋值  
8.          \}  
9.             
10.         // 为了保持票数的一致，票数要静态  
11.         static int tick = 20;  
12.            
13.         // 创建一个静态钥匙  
14.         static Object ob = "aa";//值是任意的  
15.            
16.         // 重写run方法，实现买票操作  
17.         @Override  
18.         public void run() \{  
19.             while (tick > 0) \{  
20.                 synchronized (ob) \{// 这个很重要，必须使用一个锁，  
21.                     // 进去的人会把钥匙拿在手上，出来后才把钥匙拿让出来  
22.                     if (tick > 0) \{  
23.                         System.out.println(getName() + "卖出了第" + tick + "张票");  
24.                         tick--;  
25.                     \} else \{  
26.                         System.out.println("票卖完了");  
27.                     \}  
28.                 \}  
29.                 try \{  
30.                      sleep(1000)；//休息一秒  
31.                 \} catch (InterruptedException e) \{  
32.                     e.printStackTrace();  
33.                 \}  
34.                
35.             \}  
36.     \}  
37.    
38. \}  
39.    
40.

（二）创建主方法调用类

\[plain\]  [view plain][]   [copy][view plain]

1.  package com.xykj.threadStation;  
2.     
3.  public class MainClass \{  
4.      /\*\*  
5.       \* java多线程同步锁的使用  
6.       \* 示例：三个售票窗口同时出售10张票  
7.       \* \*/  
8.      public static void main(String\[\] args) \{  
9.          //实例化站台对象，并为每一个站台取名字  
10.          Station station1=new Station("窗口1");  
11.          Station station2=new Station("窗口2");  
12.          Station station3=new Station("窗口3");  
13.        
14.         // 让每一个站台对象各自开始工作  
15.          station1.start();  
16.          station2.start();  
17.          station3.start();  
18.        
19.     \}  
20.    
21. \}

程序运行结果：

![20160913122535531][]

可以看到票数是不会有错的！

三．示例二：两个人AB通过一个账户A在柜台取钱和B在ATM机取钱！

程序分析：钱的数量要设置成一个静态的变量。两个人要取的同一个对象值

（一）创建一个Bank类

\[plain\]  [view plain][]   [copy][view plain]

1.     
2.  package com.xykj.bank;  
3.     
4.  public class Bank \{  
5.     
6.      // 假设一个账户有1000块钱  
7.      static int money = 1000;  
8.         
9.      // 柜台Counter取钱的方法  
10.     public void Counter(int money) \{// 参数是每次取走的钱  
11.         Bank.money -= money;//取钱后总数减少  
12.         System.out.println("A取走了" + money + "还剩下" + (Bank.money));  
13.     \}  
14.        
15.     // ATM取钱的方法  
16.     public void ATM(int money) \{// 参数是每次取走的钱  
17.         Bank.money -= money;//取钱后总数减少  
18.         System.out.println("B取走了" + money + "还剩下" + (Bank.money));  
19.     \}  
20.        
21. \}

（二）创建一个PersonA类

\[plain\]  [view plain][]   [copy][view plain]

1.  package com.xykj.bank;  
2.     
3.  public class PersonA extends Thread \{  
4.      // 创建银行对象  
5.      Bank bank;  
6.         
7.      // 通过构造器传入银行对象，确保两个人进入的是一个银行  
8.      public PersonA(Bank bank) \{  
9.           this.bank = bank;  
10.     \}  
11.       
12.     //重写run方法，在里面实现使用柜台取钱  
13.     @Override  
14.         public void run() \{  
15.             while (Bank.money >= 100) \{  
16.                 bank.Counter(100);// 每次取100块  
17.             try \{  
18.                 sleep(100);// 取完休息0.1秒  
19.             \} catch (InterruptedException e) \{  
20.                 e.printStackTrace();  
21.             \}  
22.         \}  
23.     \}  
24. \}

（三）创建一个PersonB类

\[plain\]  [view plain][]   [copy][view plain]

1.  package com.xykj.bank;  
2.     
3.  public class PersonB extends Thread \{  
4.      // 创建银行对象  
5.      Bank bank;  
6.         
7.      // 通过构造器传入银行对象，确保两个人进入的是一个银行  
8.      public PersonB(Bank bank) \{  
9.          this.bank = bank;  
10.     \}  
11.        
12.     // 重写run方法，在里面实现使用柜台取钱  
13.     @Override  
14.     public void run() \{  
15.         while (Bank.money >= 200) \{  
16.             bank.ATM(200);// 每次取200块  
17.             try \{  
18.                 sleep(100);// 取完休息0.1秒  
19.             \} catch (InterruptedException e) \{  
20.                 e.printStackTrace();  
21.             \}  
22.         \}  
23.            
24.     \}  
25. \}  
26.

（四）创建主方法的调用类

\[plain\]  [view plain][]   [copy][view plain]

1.  package com.xykj.bank;  
2.     
3.  public class MainClass \{  
4.      /\*\*  
5.       \* 两个人AB通过一个账户A在柜台取钱和B在ATM机取钱  
6.       \* \*/  
7.      public static void main(String\[\] args) \{  
8.          // 实力化一个银行对象  
9.          Bank bank = new Bank();  
10.         // 实例化两个人，传入同一个银行的对象  
11.         PersonA pA = new PersonA(bank);  
12.         PersonB pB = new PersonB(bank);  
13.         // 两个人开始取钱  
14.         pA.start();  
15.         pB.start();  
16.            
17.     \}  
18.    
19. \}

运行结果：

![20160913123938063][]

可以看到取完就停止运行了。

四．示例三：龟兔赛跑问题

龟兔赛跑：20米     //只要为了看到效果，所有距离缩短了

要求：

1.兔子每秒0.5米的速度，每跑2米休息10秒，

2.乌龟每秒跑0.1米，不休息

3.其中一个跑到终点后另一个不跑了！

程序设计思路：

1.创建一个Animal动物类，继承Thread，编写一个running抽象方法，重写run方法，把running方法在run方法里面调用。

2.创建Rabbit兔子类和Tortoise乌龟类，继承动物类

3.两个子类重写running方法

4.本题的第3个要求涉及到线程回调。需要在动物类创建一个回调接口，创建一个回调对象

（一）创建Animal动物类

\[plain\]  [view plain][]   [copy][view plain]

1.  package com.xykj.rabbit\_tortoise;  
2.     
3.  public abstract class Animal extends Thread\{  
4.    
5.      public double length=20;//比赛的长度  
6.        
7.      public abstract void runing();//抽象方法需要子类实现  
8.        
9.      //在父类重写run方法，在子类只要重写running方法就可以了  
10.     @Override  
11.     public void run() \{  
12.         super.run();  
13.         while (length>0) \{  
14.              runing();  
15.         \}  
16.     \}  
17.       
18.     //在需要回调数据的地方（两个子类需要），声明一个接口  
19.     public static interface Calltoback\{  
20.         public void win();  
21.     \}  
22.       
23.     //2.创建接口对象  
24.     public Calltoback calltoback;  
25.       
26. \}

（二）创建Rabbit兔子类

\[plain\]  [view plain][]   [copy][view plain]

1.  package com.xykj.rabbit\_tortoise;  
2.     
3.  public class Rabbit extends Animal \{  
4.         
5.      public Rabbit() \{  
6.          setName("兔子");// Thread的方法，给线程赋值名字  
7.      \}  
8.         
9.      // 重写running方法，编写兔子的奔跑操作  
10.     @Override  
11.     public void runing() \{  
12.         // 跑的距离  
13.         double dis = 0.5;  
14.         length -= dis;//跑完后距离减少  
15.         if (length <= 0) \{  
16.             length = 0;  
17.             System.out.println("兔子获得了胜利");  
18.             //给回调对象赋值，让乌龟不要再跑了  
19.             if (calltoback != null) \{  
20.                 calltoback.win();  
21.             \}  
22.         \}  
23.         System.out.println("兔子跑了" + dis + "米，距离终点还有" + (int)length + "米");  
24.            
25.         if (length % 2 == 0) \{// 两米休息一次  
26.             try \{  
27.                 sleep(1000);  
28.             \} catch (InterruptedException e) \{  
29.                 e.printStackTrace();  
30.             \}  
31.         \}  
32.     \}  
33. \}  
34.

（三）创建Tortoise乌龟类

\[plain\]  [view plain][]   [copy][view plain]

1.     
2.  package com.xykj.rabbit\_tortoise;  
3.     
4.  public class Tortoise extends Animal \{  
5.         
6.      public Tortoise() \{  
7.          setName("乌龟");// Thread的方法，给线程赋值名字  
8.      \}  
9.         
10.     // 重写running方法，编写乌龟的奔跑操作  
11.     @Override  
12.     public void runing() \{  
13.         // 跑的距离  
14.         double dis = 0.1;  
15.         length -= dis;  
16.         if (length <= 0) \{  
17.             length = 0;  
18.             System.out.println("乌龟获得了胜利");  
19.             // 让兔子不要在跑了  
20.             if (calltoback != null) \{  
21.                 calltoback.win();  
22.             \}  
23.         \}  
24.         System.out.println("乌龟跑了" + dis + "米，距离终点还有" + (int) length + "米");  
25.         try \{  
26.             sleep(100);  
27.         \} catch (InterruptedException e) \{  
28.             e.printStackTrace();  
29.         \}  
30.     \}  
31. \}

（四）创建一个让动物线程停止的类，这里要实现回调接口

\[plain\]  [view plain][]   [copy][view plain]

1.  package com.xykj.rabbit\_tortoise;  
2.     
3.  import com.xykj.rabbit\_tortoise.Animal.Calltoback;  
4.     
5.  public class LetOneStop implements Calltoback \{  
6.    
7.      // 动物对象  
8.      Animal an;  
9.        
10.     // 获取动物对象，可以传入兔子或乌龟的实例  
11.     public LetOneStop(Animal an) \{  
12.         this.an = an;  
13.     \}  
14.       
15.     //让动物的线程停止  
16.     @Override  
17.     public void win() \{  
18.         // 线程停止  
19.         an.stop();  
20.     \}  
21.        
22. \}  
23.    
24.    
25.

（五）创建一个主方法调用类，

\[plain\]  [view plain][]   [copy][view plain]

1.  package com.xykj.rabbit\_tortoise;  
2.     
3.  public class MainClass \{  
4.      /\*\*  
5.       \* 龟兔赛跑：20米        
6.       \* \*/  
7.      public static void main(String\[\] args) \{  
8.          //实例化乌龟和兔子  
9.          Tortoise tortoise = new Tortoise();  
10.         Rabbit rabbit = new Rabbit();  
11.         //回调方法的使用，谁先调用calltoback方法，另一个就不跑了  
12.         LetOneStop letOneStop1 = new LetOneStop(tortoise);  
13.         rabbit.calltoback = letOneStop1;//让兔子的回调方法里面存在乌龟对象的值，可以把乌龟stop  
14.         LetOneStop letOneStop2 = new LetOneStop(rabbit);  
15.         tortoise.calltoback = letOneStop2;//让乌龟的回调方法里面存在兔子对象的值，可以把兔子stop  
16.         //开始跑  
17.         tortoise.start();  
18.         rabbit.start();  
19.        
20.     \}  
21.    
22. \}

运行结果：

![20160913125028600][]

可以看到结果兔子赢了。

一般来说兔子获得了胜利是在最后输出的，

但是，由于线程一直在执行所以会出现：

"兔子跑了0.5米**，**距离终点还有0米"还没来得及输出完，

而“兔子获得了胜利”已经输出完毕了。

五．实例四:

在一个KFC内，服务员负责生产食物，消费者负责消费食物；

当生产到一定数量可以休息一下，直到消费完食物，再马上生产，一直循环

程序涉及到的内容：

1.这设计到java模式思想：生产者消费者模式

2.要保证操作对象的统一性，即消费者和服务者都是跟同一个KFC发生关系的，KFC只能new一次

3.this.notifyAll();和 this.wait();一个是所有唤醒的意思，一个是让自己等待的意思；

比如本题中，生产者生产完毕后，先所有唤醒（包括消费者和生产者），再让所有自己（生产者）等待

这时，消费者开始消费，直到食材不够，先所有唤醒（包括消费者和生产者），再让所有自己（消费者）等待

一直执行上面的操作的循环

4.生产者和消费者都要继承Thread，才能实现多线程的启动

程序设计的步骤思路：

1.创建一个食物类Food，有存放/获取食物的名称的方法

2.创建一个KFC类，有生产食物和消费食物的方法

3.创建一个客户类Customer，继承Thread，重写run方法，在run方法里面进行消费食物操作

4.创建一个服务员类Waiter，继承Thread，重写run方法，在run方法里面进行生产食物的操作

5.创建主方法的调用类

（一）创建一个食物类Food

\[plain\]  [view plain][]   [copy][view plain]

1.  package com.xykj.producer\_consumer;  
2.     
3.  public class Food \{  
4.      String name="";  
5.      //通过构造方法传入食物的名字  
6.      public Food(String name) \{  
7.          this.name=name;  
8.      \}  
9.      //get、set 方法  
10.     public String getName() \{  
11.         return name;  
12.     \}  
13.     public void setName(String name) \{  
14.         this.name = name;  
15.     \}  
16. \}

（二）创建一个KFC类

\[plain\]  [view plain][]   [copy][view plain]

1.  package com.xykj.producer\_consumer;  
2.  import java.util.ArrayList;  
3.  import java.util.List;  
4.     
5.  public class KFC \{  
6.    
7.      //食物的种类  
8.      String\[\] names = \{ "薯条", "烧板", "鸡翅", "可乐" \};  
9.        
10.     //生产的最大值，到达后可以休息  
11.     static final int Max = 20;  
12.       
13.     //存放食物的集合  
14.     List foods = new ArrayList();  
15.        
16.     // 生产食物的方法  
17.     public void prod(int index) \{  
18.         synchronized (this) \{  
19.             // 如果食物数量大于20  
20.             while (foods.size() > Max) \{  
21.                 System.out.println("食材够了");  
22.                 this.notifyAll();//这个唤醒是针对生产者和消费者，有all  
23.                 try \{  
24.                     String name=Thread.currentThread().getName();  
25.                     this.wait();//这个唤醒是针对生产者，没有all  
26.                     System.out.println("生产者："+name);  
27.                 \} catch (InterruptedException e) \{  
28.                     e.printStackTrace();  
29.                 \}  
30.             \}  
31.                
32.             // 开始生产食物食物//有一点要注意的  
33.             System.out.println("开始生产食物");  
34.             for (int i = 0; i < index; i++) \{  
35.                 Food food = new Food(names\[(int) (Math.random() \* 4)\]);  
36.                 foods.add(food);  
37.                 System.out.println("生产了" + food.getName() + foods.size());  
38.             \}  
39.         \}  
40.     \}  
41.        
42.     // 消费食物的方法  
43.     public void consu(int index) \{   
44.         synchronized (this) \{  
45.             while (foods.size() < index) \{  
46.                 System.out.println("食材不够了");  
47.                 this.notifyAll();//这个唤醒是针对生产者和消费者，有all  
48.                 try \{  
49.                     String name=Thread.currentThread().getName();  
50.                     this.wait();//这个唤醒是针对消费者，没有all  
51.                     System.out.println("消费者："+name);  
52.                 \} catch (InterruptedException e) \{  
53.                     e.printStackTrace();  
54.                 \}  
55.             \}  
56.             // 足够消费  
57.             System.out.println("开始消费");  
58.             for (int i = 0; i < index; i++) \{  
59.                 Food food = foods.remove(foods.size() - 1);  
60.                 System.out.println("消费了一个" + food.getName() + foods.size());  
61.             \}  
62.         \}  
63.     \}  
64. \}  
65.

（三）创建一个客户类Customer

\[plain\]  [view plain][]   [copy][view plain]

1.  package com.xykj.producer\_consumer;  
2.     
3.  public class Customers extends Thread\{  
4.      KFC kfc;  
5.      //KFC要传入，保证每一个服务员和用户在同一个KFC对象内  
6.      public Customers(KFC kfc) \{  
7.          this.kfc=kfc;  
8.      \}  
9.      @Override  
10.     public void run() \{  
11.         int size=(int)(Math.random()\*5);//每次要消费的食物的数量  
12.         while (true) \{  
13.             kfc.consu(size);//在消费的方法里面传入参数  
14.         \}  
15.        
16.     \}  
17. \}  
18.

（四）创建一个服务员类Waiter

\[plain\]  [view plain][]   [copy][view plain]

1.  package com.xykj.producer\_consumer;  
2.     
3.  public class Waiter extends Thread\{  
4.      KFC kfc;  
5.      //KFC要传入，保证每一个服务员和用户在同一个KFC对象内  
6.      public Waiter(KFC kfc) \{  
7.          this.kfc=kfc;  
8.      \}  
9.      @Override  
10.     public void run() \{  
11.         int size=(int)(Math.random()\*5)+5;//每次生产的数量  
12.         while (true) \{  
13.             kfc.prod(size);//传入每次生产的数量  
14.         \}  
15.        
16.     \}  
17. \}

（五）创建主方法的调用类

\[plain\]  [view plain][]   [copy][view plain]

1.  package com.xykj.producer\_consumer;  
2.     
3.  public class MainClass \{  
4.      /\*\*  
5.       \* 生产者消费者模式  
6.       \*  
7.       \* \*/  
8.      public static void main(String\[\] args) \{  
9.        
10.         // 只实例化一个KFC对象，保证每一个服务员和用户在同一个KFC对象内  
11.         KFC kfc = new KFC();  
12.           
13.         //实例化4个客户对象  
14.         Customers c1 = new Customers(kfc);  
15.         Customers c2 = new Customers(kfc);  
16.         Customers c3 = new Customers(kfc);  
17.         Customers c4 = new Customers(kfc);  
18.           
19.         //实例化3个服务员对象  
20.         Waiter waiter1 = new Waiter(kfc);  
21.         Waiter waiter2 = new Waiter(kfc);  
22.         Waiter waiter3 = new Waiter(kfc);  
23.           
24.         //让所有的对象的线程都开始工作  
25.         waiter1.start();  
26.         waiter2.start();  
27.         waiter3.start();  
28.         c1.start();  
29.         c2.start();  
30.         c3.start();  
31.         c4.start();  
32.     \}  
33.        
34. \}  
35.    
36.

六．示例五：设计四个线程对象对同一个数据进行操作， 两个线程执行减操作，两个线程执行加操作。

程序分析：1.创建一个ThreadAddSub类继承Thread，重写run方法

2.在run方法里面实现加和减的操作，每次操作后睡眠1秒

3.创建主方法调用类

（一）创建一个ThreadAddSub类

\[plain\]  [view plain][]   [copy][view plain]

1.  package com.xykj.add;  
2.     
3.  public class ThreadAddSub extends Thread \{  
4.      //判断要进行的操作  
5.      boolean operate = true;  
6.      //要操作的数  
7.      static int sum = 0;  
8.         
9.      // 把操作运算通过构造方法传进来  
10.     public ThreadAddSub(boolean operate) \{  
11.         super();  
12.         this.operate = operate;  
13.     \}  
14.        
15.     @Override  
16.     public void run() \{  
17.         super.run();  
18.         while (true) \{  
19.             if (operate) \{  
20.                 sum+=5;  
21.                 System.out.println("加后，sum="+sum);  
22.             \} else \{  
23.                 sum-=4;  
24.                 System.out.println("减后，sum="+sum);  
25.             \}  
26.             try \{  
27.                 sleep(500);// 睡眠0.5秒  
28.             \} catch (InterruptedException e) \{  
29.                 e.printStackTrace();  
30.             \}  
31.         \}  
32.        
33.     \}  
34. \}

（二）创建主方法调用类

\[plain\]  [view plain][]   [copy][view plain]

1.  emptypackage com.xykj.add;  
2.     
3.  public class MainClass \{  
4.      /\*\*  
5.       \* (线程同步)  
6.       \* \*/  
7.      public static void main(String\[\] args) \{  
8.        
9.          //创建一个存放ThreadAddSub对象的数组  
10.         ThreadAddSub\[\] tSub=new ThreadAddSub\[4\];  
11.         for (int i = 0; i < tSub.length; i++) \{  
12.           
13.         //把实例化ThreadAddSub对象赋值到数组内  
14.         //第一三个是true，二四个是false  
15.         tSub\[i\]=new ThreadAddSub(i%2==0?true:false);  
16.           
17.         //让线程开始工作  
18.         tSub\[i\].start();  
19.         \}  
20.        
21.     \}  
22.    
23. \}

线程示例总结：

代码块锁是一个防止数据发生错误的一个重要手段。

对象的统一性是非常重要的，这要想到对象的传入问题，

要操作的对象只能new一次，其他的操作都是对这个传入的对象进行的，

才能保证数据一致性，完整性和正确性。

练习题目：

1. （多线程）代码实现火车站4个卖票窗口同时买票的场景，输出示例：  
窗口1卖票  
窗口2卖票  
窗口1卖票  
...  
2. （线程同步）代码实现火车站4个窗口同时卖100张票的代码逻辑，同一个窗口不能卖同一  
张张票。  
3. （线程通信）小明打算去提款机上取钱，发现卡上没钱，这时候他告知妈妈去存钱，妈妈  
存了钱了，告知小明存好了可以取钱了。(PS:小明分多次取钱，每次取100，当发现钱不够  
100，就等待妈妈存钱，小明他妈每次存2000，当发现钱小于100就存钱，就存钱，并且  
通知小明去取钱，当大于100就等待小明钱不够是再存)  
4. (线程同步)设计四个线程对象对同一个数据进行操作，两个线程执行减操作，两个线程执行  
加操作。  
5. （线程通信）制作两个线程对象，要求用同步块的方式使第一个线程运行2次，然后将自己  
阻塞起来，唤醒第二个线程，第二个线程再运行2次，然后将自己阻塞起来，唤醒第一个线  
程……两个线程交替执行。  
6. （线程同步）设计4个线程，其中两个线程每次对j增加1，另外两个线程对j每次减少1。  
7. （线程通信）子线程循环10次，接着主线程循环100，接着又回到子线程循环10次，接着  
再回到主线程又循环100，如此循环50次。

[view plain]: https://blog.csdn.net/wenzhi20102321/article/details/52524545#
[20160913122535531]: /images/20220524/7657d6bbf8c742a19f1a74e7539706e4.png
[20160913123938063]: /images/20220524/e4a223247122456598a835acd34988eb.png
[20160913125028600]: /images/20220524/4925790d98614a388958012e57927cd1.png