java多线程编程实例

最新推荐文章于 2025-06-17 15:18:32 发布
最新推荐文章于 2025-06-17 15:18:32 发布
阅读量198 收藏 2
点赞数 1
分类专栏： 技术类

        这篇文章主要介绍了java多线程编程实例，分享了几则多线程的实例代码，具有一定参考价值，加深多线程编程的理解还是很有帮助的，需要的朋友可以参考下。

1.三个售票窗口同时出售20张票

程序分析：
    (1)票数要使用同一个静态值
    (2)为保证不会出现卖出同一个票数，要java多线程同步锁。
设计思路：
    (1)创建一个站台类Station，继承Thread，重写run方法，在run方法里面执行售票操作！售票要使用同步锁：即有一个站台卖这张票时，其他站台要等这张票卖完！
    (2)创建主方法调用类

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

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

（二）创建主方法调用类

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

程序运行结果：

窗口1卖出了第20张票
窗口2卖出了第19张票
窗口3卖出了第18张票
窗口3卖出了第17张票
窗口1卖出了第16张票
窗口2卖出了第15张票
窗口3卖出了第14张票
窗口1卖出了第13张票
窗口2卖出了第12张票
窗口2卖出了第11张票
窗口1卖出了第10张票
窗口3卖出了第9张票
窗口3卖出了第8张票
窗口1卖出了第7张票
窗口2卖出了第6张票
窗口3卖出了第5张票
窗口1卖出了第4张票
窗口2卖出了第3张票
窗口3卖出了第2张票
窗口1卖出了第1张票
票卖完了

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

2.两个人AB通过一个账户A在柜台取钱和B在ATM机取钱！

程序分析：
        钱的数量要设置成一个静态的变量，两个人要取的同一个对象值。
（一）创建一个Bank类
  1. package com.thread.demo.demo2;
  2.  
  3. import java.util.Objects;
  4.  
  5. public class Bank {
  6. 	// 假设一个账户有1000块钱  
  7. 	static double money = 1000;
  8. 	// 柜台Counter取钱的方法  
  9. 	private void Counter(double money) {
  10. 		Bank.money -= money;
  11. 		System.out.println("柜台取钱" + money + "元，还剩" + Bank.money + "元！");
  12. 	}
  13. 	// ATM取钱的方法  
  14. 	private void ATM(double money) {
  15. 		Bank.money -= money;
  16. 		System.out.println("ATM取钱" + money + "元，还剩" + Bank.money + "元！");
  17. 	}
  18. 	
  19. 	//提供一个对外取款途径，防止直接调取方法同时取款时，并发余额显示错误
  20. 	public synchronized void outMoney(double money, String mode) throws Exception{
  21. 		if(money > Bank.money){
  22. 			//校验余额是否充足
  23. 			throw new Exception("取款金额"+money+",余额只剩"+Bank.money+"，取款失败");
  24. 		}
  25. 		if(Objects.equals(mode, "ATM")){
  26. 			ATM(money);
  27. 		} else {
  28. 			Counter(money);
  29. 		}
  30. 	}
  31.  
  32. }

（二）创建一个PersonA类

  1. package com.thread.demo.demo2;
  2.  
  3. public class PersonA extends Thread {
  4.  
  5. 	Bank bank;
  6. 	
  7. 	String mode;
  8.  
  9. 	public PersonA(Bank bank, String mode) {
  10. 		this.mode = mode;
  11. 		this.bank = bank;
  12. 	}
  13.  
  14. 	public void run (){
  15. 		while(bank.money >= 100){
  16. 			try {
  17. 				bank.outMoney(100, mode);
  18. 			} catch (Exception e1) {
  19. 				// TODO Auto-generated catch block
  20. 				e1.printStackTrace();
  21. 			}
  22. 			try {
  23. 				sleep(100);
  24. 			} catch (InterruptedException e) {
  25. 				// TODO Auto-generated catch block
  26. 				e.printStackTrace();
  27. 			}
  28. 		}
  29. 	}
  30. }

（三）创建一个PersonB类

  1. package com.thread.demo.demo2;
  2.  
  3. public class PersonB extends Thread {
  4. 	Bank bank;
  5. 	
  6. 	String mode;
  7.  
  8. 	public PersonB(Bank bank, String mode) {
  9. 		this.bank = bank;
  10. 		this.mode = mode;
  11. 	}
  12.  
  13. 	public void run() {
  14. 		while (bank.money >= 200) {
  15. 			try {
  16. 				bank.outMoney(200, mode);
  17. 			} catch (Exception e1) {
  18. 				// TODO Auto-generated catch block
  19. 				e1.printStackTrace();
  20. 			}
  21. 			try {
  22. 				sleep(100);
  23. 			} catch (InterruptedException e) {
  24. 				// TODO Auto-generated catch block
  25. 				e.printStackTrace();
  26. 			}
  27. 		}
  28. 		
  29. 	}
  30. }

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

  1. package com.thread.demo.demo2;
  2.  
  3. /**
  4.  * 两个人AB通过一个账户A在柜台取钱和B在ATM机取钱
  5.  * */
  6. public class MainClass {
  7. 	public static void main(String[] args) {
  8. 		Bank bank = new Bank();
  9. 		// 实例化两个人，传入同一个银行的对象
  10. 		PersonA a = new PersonA(bank, "Counter");
  11. 		PersonB b = new PersonB(bank, "ATM");
  12. 		a.start();
  13. 		b.start();
  14. 	}
  15. }
运行结果：

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

3.龟兔赛跑问题

龟兔赛跑：2000米 
要求：
    (1)兔子每 0.1 秒 5 米的速度，每跑20米休息1秒;
    (2)乌龟每 0.1 秒跑 2 米，不休息；
    (3)其中一个跑到终点后另一个不跑了！
程序设计思路：
    (1)创建一个Animal动物类，继承Thread，编写一个running抽象方法，重写run方法，把running方法在run方法里面调用。
    (2)创建Rabbit兔子类和Tortoise乌龟类，继承动物类
    (3)两个子类重写running方法
    (4)本题的第3个要求涉及到线程回调。需要在动物类创建一个回调接口，创建一个回调对象。

（一）创建Animal动物类

  1. package com.thread.demo.demo3;
  2.  
  3. public abstract class Animal extends Thread {
  4. 	public int length = 2000;// 比赛长度
  5.  
  6. 	public abstract void runing();
  7.  
  8. 	@Override
  9. 	public void run() {
  10. 		super.run();
  11. 		while (length > 0) {
  12. 			runing();
  13. 		}
  14. 	}
  15.  
  16. 	// 在需要回调数据的地方（两个子类需要），声明一个接口
  17. 	public static interface Calltoback {
  18. 		public void win();
  19. 	}
  20.  
  21. 	// 2.创建接口对象
  22. 	public Calltoback calltoback;
  23.  
  24. }

（二）创建Rabbit兔子类

  1. package com.thread.demo.demo3;
  2.  
  3. public class Rabbit extends Animal {
  4.  
  5. 	public Rabbit() {
  6. 		setName("兔子");
  7. 	}
  8.  
  9. 	@Override
  10. 	public void runing() {
  11. 		//兔子速度
  12. 		int dis = 5;
  13. 		length -= dis;
  14.  
  15. 		System.out.println("兔子跑了" + dis + "米，距离终点还有" + length + "米");
  16. 		if (length <= 0) {
  17. 			length = 0;
  18. 			System.out.println("兔子获得了胜利");
  19. 			// 给回调对象赋值，让乌龟不要再跑了
  20. 			if (calltoback != null) {
  21. 				calltoback.win();
  22. 			}
  23. 		}
  24.  
  25. 		try {
  26. 			if ((2000 - length) % 20 == 0) {	// 每20米休息一次,休息时间是1秒
  27. 				sleep(1000);
  28. 			} else {				//没0.1秒跑5米
  29. 				sleep(100);
  30. 			}
  31. 		} catch (InterruptedException e) {
  32. 			e.printStackTrace();
  33. 		}
  34. 	}
  35.  
  36. }

（三）创建Tortoise乌龟类

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

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

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

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

  1. package com.thread.demo.demo3;
  2.  
  3. public class MainClass {
  4. 	/**
  5. 	 * 龟兔赛跑：2000米
  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. 		// 让兔子的回调方法里面存在乌龟对象的值，可以把乌龟stop
  14. 		rabbit.calltoback = letOneStop1;
  15. 		LetOneStop letOneStop2 = new LetOneStop(rabbit);
  16. 		// 让乌龟的回调方法里面存在兔子对象的值，可以把兔子stop
  17. 		tortoise.calltoback = letOneStop2;
  18. 		// 开始跑
  19. 		tortoise.start();
  20. 		rabbit.start();
  21. 	}
  22.  
  23. }

运行结果：


4. 线程示例总结

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

    （2）对象的统一性是非常重要的，这要想到对象的传入问题，要操作的对象只能new一次，其他的操作都是对这个传入的对象进行的，才能保证数据一致性，完整性和正确性。

java多线程示例
03-02
Java中的多线程有三种实现方式： 1.继承Thread类，重写run方法。Thread本质上也是一个实现了Runnable的实例，他代表一个线程的实例，并且启动线程的唯一方法就是通过Thread类的start方法。 2.实现Runnable接口，并实现该接口的run()方法.创建一个Thread对象，用实现的Runnable接口的对象作为参数实例化Thread对象，调用此对象的start方法。 本示例演示和wait和sleep、线程锁的使用。
java多线程实例
糖糖糖糖糖先森
12-23 1395
实现线程的方式有两种： 1、继承java.lang.Thread，并重写它的run()方法，将线程的执行主体放入其中。 2、实现java.lang.Runnable接口，实现它的run()方法，并将线程的执行主体放入其中。 ==多线程的执行逻辑: 当主线程被挂起时, 其它就绪的线程会根据选择最 实现线程的方式有两种： 1、继承java.lang.Thread，并重写它的run(
Java多线程编程全面解析：五种实现方式与最佳实践
最新发布
N0t_F0und_404的博客
06-17 1005
本文全面解析Java多线程编程的五种核心实现方式：继承Thread类、实现Runnable接口、实现Callable接口、使用CompletableFuture和并行流。每种方式都包含代码示例，并详细分析其适用场景、优势和劣势。针对不同需求提供选择策略：简单任务用Runnable、需返回值用Callable、数据处理用并行流、复杂异步流程用CompletableFuture。文章还介绍了CountDownLatch等并发工具类，并给出线程池使用和多线程安全的最佳实践建议，涵盖从基础到高级的完整知识体系。
java多线程的常见例子
热门推荐
wenzhi的博客
09-13 6万+
本文有比较常见的java多线程问题的解决方法。对部分知识也有总结。
java多线程案例
BigData
05-22 337
package com.dl.thread; import java.util.concurrent.*; public class Demo_2 { public static void main(String[] args) throws ExecutionException, InterruptedException { ExecutorService executor = Executors.newFixedThreadPool(10); int ...
JAVA多线程编程实例详解
08-25
JAVA多线程编程实例详解 JAVA多线程编程是指在一个程序中可以同时运行多个线程，以提高程序的执行效率和响应速度。JAVA多线程编程可以通过继承Thread类或实现Runnable接口来实现。 在JAVA中，线程是系统进行资源...
java 多线程编程实例
10-16
内容是两个多线程编程的demo: 1.一个线程添加，一个线程减少 2.a线程呼叫b线程，b线程呼叫c线程，c线程呼叫a线程。 能学到： 在学习多线程编程中，我们要把大家用的对象独立出来，然后作为一个 变量传递到各个线程...
Java多线程编程实例
05-07
本书“Java多线程编程实例”深入浅出地讲解了如何在Java环境中实现多线程操作，尽管出版时间较早，但其内容的经典性和实用性使其在现代开发中仍具有极高的参考价值。 首先，我们要理解Java中的线程是如何创建的。...
Java多线程实例
09-03
本文给大家介绍java多线程实例，对java多线程知识感兴趣的朋友参考下吧
java 多线程的一个例子java 多线程的一个例子
06-10
java 多线程的一个例子java 多线程的一个例子java 多线程的一个例子java 多线程的一个例子
java多线程的编程实例
weixin_30645617的博客
09-09 120
java中可有两种方式实现多线程： 一种是继承Thread类； 一种是实现Runnable接口； Thread类 是在java.lang包中定义的。一个类只要继承了Thread类同时覆写了本类中的run()方法就可以实现多线程操作了，但限制是一个类只能继承一个父类 package org.thread.demo; class MyThread ext...
Java：多线程实例
qq_43220266的博客
01-09 369
通过Thread类实现多线程 Thread的run()方法为普通方法。 Thread的start()的方法可以启动多线程 另外介绍几个常用的操作方法 ①线程休眠(sleep方法)：指的是让线程暂缓执行一下，让线程进入阻塞状态，等到了预计时间之后再恢复执行 线程休眠会交出CPU，让CPU去执行其他的任务。sleep方法不会释放锁。 ②线程让步(yield()方法)：是调用yield方法会让当前线程交...
Java多线程编程实例与源码解析
在本例中，如果标题所指的“java多线程实例 源码”是指一个包含具体Java多线程编程实例代码的文件，那么我们可以假设其中包含了如何通过上述方式创建线程、如何利用同步机制保护共享数据、如何使用线程池以及线程的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值