Java多线程编程实例

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

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

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

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

（二）创建主方法调用类

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

程序运行结果：
窗口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. A和B两个人使用同一个账户同时在柜台取钱和在ATM机取钱！

程序分析：
钱的数量要设置成一个静态的变量，两个人要取的同一个对象值。
（一）创建一个Bank类

package com.thread.demo.demo2;
 
import java.util.Objects;
 
public class Bank {
	// 假设一个账户有1000块钱  
	static double money = 1000;
	// 柜台Counter取钱的方法  
	private void Counter(double money) {
		Bank.money -= money;
		System.out.println("柜台取钱" + money + "元，还剩" + Bank.money + "元！");
	}
	// ATM取钱的方法  
	private void ATM(double money) {
		Bank.money -= money;
		System.out.println("ATM取钱" + money + "元，还剩" + Bank.money + "元！");
	}
	
	//提供一个对外取款途径，防止直接调取方法同时取款时，并发余额显示错误
	public synchronized void outMoney(double money, String mode) throws Exception{
		if(money > Bank.money){
			//校验余额是否充足
			throw new Exception("取款金额"+money+",余额只剩"+Bank.money+"，取款失败");
		}
		if(Objects.equals(mode, "ATM")){
			ATM(money);
		} else {
			Counter(money);
		}
	}
}

（二）创建一个PersonA类

package com.thread.demo.demo2;
 
public class PersonA extends Thread {
 
	Bank bank;
	
	String mode;
 
	public PersonA(Bank bank, String mode) {
		this.mode = mode;
		this.bank = bank;
	}
 
	public void run (){
		while(bank.money >= 100){
			try {
				bank.outMoney(100, mode);
			} catch (Exception e1) {
				// TODO Auto-generated catch block
				e1.printStackTrace();
			}
			try {
				sleep(100);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
	}
}

（三）创建一个PersonB类

package com.thread.demo.demo2;
 
public class PersonB extends Thread {
	Bank bank;
	
	String mode;
 
	public PersonB(Bank bank, String mode) {
		this.bank = bank;
		this.mode = mode;
	}
 
	public void run() {
		while (bank.money >= 200) {
			try {
				bank.outMoney(200, mode);
			} catch (Exception e1) {
				// TODO Auto-generated catch block
				e1.printStackTrace();
			}
			try {
				sleep(100);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}		
	}
}

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

package com.thread.demo.demo2;
 
/**
 * 两个人AB通过一个账户A在柜台取钱和B在ATM机取钱
 * */
public class MainClass {
	public static void main(String[] args) {
		Bank bank = new Bank();
		// 实例化两个人，传入同一个银行的对象
		PersonA a = new PersonA(bank, "Counter");
		PersonB b = new PersonB(bank, "ATM");
		a.start();
		b.start();
	}
}

运行结果：

可以看到取完就停止运行了。
小结：
（1）代码块锁是一个防止数据发生错误的一个重要手段；
（2）对象的统一性是非常重要的，这要想到对象的传入问题，要操作的对象只能new一次，其他的操作都是对这个传入的对象进行的，才能保证数据一致性，完整性和正确性。在本题中如果a和b传入的不是同一个bank对象，那么a和b操作的就是俩个不同的账户，不具有同步的说法了。

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个要求涉及到线程回调。需要在动物类创建一个回调接口，创建一个回调对象。
tip:博主觉得测试的时候可以将比赛长度由2000米改成200米来缩短运行时间，兔子和乌龟跑的实在太慢了。
（一）创建Animal动物类

package com.thread.demo.demo3;
 
public abstract class Animal extends Thread {
	public int length = 2000;// 比赛长度
 
	public abstract void runing();
 
	@Override
	public void run() {
		super.run();
		while (length > 0) {
			runing();
		}
	}
 
	// 在需要回调数据的地方（两个子类需要），声明一个接口
	public static interface Calltoback {
		public void win();
	}
 
	// 2.创建接口对象
	public Calltoback calltoback;
 
}

（二）创建Rabbit兔子类

package com.thread.demo.demo3;
 
public class Rabbit extends Animal {
 
	public Rabbit() {
		setName("兔子");
	}
 
	@Override
	public void runing() {
		//兔子速度
		int dis = 5;
		length -= dis;
 
		System.out.println("兔子跑了" + dis + "米，距离终点还有" + length + "米");
		if (length <= 0) {
			length = 0;
			System.out.println("兔子获得了胜利");
			// 给回调对象赋值，让乌龟不要再跑了
			if (calltoback != null) {
				calltoback.win();
			}
		}
 
		try {
			if ((2000 - length) % 20 == 0) {	// 每20米休息一次,休息时间是1秒
				sleep(1000);
			} else {				//没0.1秒跑5米
				sleep(100);
			}
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	}
}

（三）创建Tortoise乌龟类

package com.thread.demo.demo3;
 
public class Tortoise extends Animal {
	public Tortoise() {
		setName("乌龟");// Thread的方法，给线程赋值名字
	}
 
	// 重写running方法，编写乌龟的奔跑操作
	@Override
	public void runing() {
		// 乌龟速度
		int dis = 2;
		length -= dis;
		System.out.println("乌龟跑了" + dis + "米，距离终点还有" + length + "米");
		if (length <= 0) {
			length = 0;
			System.out.println("乌龟获得了胜利");
			// 让兔子不要在跑了
			if (calltoback != null) {
				calltoback.win();
			}
		}
		try {
			sleep(100);						//没0.1秒跑2米
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	}
 
}

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

package com.thread.demo.demo3;
 
import com.thread.demo.demo3.Animal.Calltoback;
 
public class LetOneStop implements Calltoback {
	// 动物对象
	Animal an;
 
	// 获取动物对象，可以传入兔子或乌龟的实例
	public LetOneStop(Animal an) {
		this.an = an;
	}
 
	// 让动物的线程停止
	@Override
	public void win() {
		// 线程停止
		an.stop();
	}
}

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

public class AnimalTest {
	public static void main(String[] args){
		
		/*
		 * 龟兔2000米赛跑比赛
		 */
		
		//1.实例化俩个动物
		Rabbit rabbit = new Rabbit();
		Tortoise tortoise = new Tortoise();
		
		//2.分别为俩个动物实例化一个回调函数，只要有动物到达终点，立即停止另一个动物的线程
		LetOneStop RWin = new LetOneStop(tortoise);
		LetOneStop TWin = new LetOneStop(rabbit);
		
		//3.将回调函数装载到动物实例上
		rabbit.calltoback = RWin;
		tortoise.calltoback = TWin;
		
		//4.比赛开始
		rabbit.start();
		tortoise.start();
	}
}

运行结果：

---

4. 多线程并发之线程汇总

假如有Thread1、Thread2、ThreaD3、Thread4四条线程分别统计C、D、E、F四个盘的大小，所有线程都统计完毕交给Thread5线程去做汇总，应当如何实现？

import java.util.*;
import java.util.concurrent.Callable;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
public class Main {
	
	static CountDownLatch latch = new CountDownLatch(5);
	
	public static void main(String[] args){
    	ExecutorService threadPool = Executors.newCachedThreadPool();
    	List<Future<Integer>> list = new ArrayList<Future<Integer>>();
    	for(int i=1;i<=5;i++){
    		list.add(threadPool.submit(new myCall(i*100)));
    	}
    	try{
    		latch.await();
        	for(Future f:list){
    			System.out.println(f.get());
        	}
    	} catch(Exception e){
    		e.printStackTrace();
    	} finally{
    		threadPool.shutdown();
    	}
    	
    }
	static class myCall implements Callable<Integer>{

		int max;
		public myCall(int max){
			this.max=max;
		}
		@Override
		public Integer call() throws Exception {
			max = (int) ((Math.random()+1)*max);
			String s = Thread.currentThread().getName()+" "+max;
			System.out.println(s);
			latch.countDown();
			return max;
		}
		
	}
}

---

5.多线程并发之顺序执行

3个线程依次打印1，2，3
第一种解法：

package com.demo.test;

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class Main {
    static int count = 0;
    static int flag=3;
    static int max=3;
    public static void main(String[] args){
        Lock lock = new ReentrantLock();
        Condition c1 = lock.newCondition();
        Condition c2 = lock.newCondition();
        Condition c3 = lock.newCondition();
        Thread t1 = new Task("A",0,lock,c1,c2);
        Thread t2 = new Task("B",1,lock,c2,c3);
        Thread t3 = new Task("C",2,lock,c3,c1);
        t3.start();
        t2.start();
        t1.start();

    }

    static class Task extends Thread {
        int target;
        Condition curr,next;
        Lock lock;
        String name;
        Task(String name,int target,Lock lock,Condition curr,Condition next){
            this.name=name;
            this.target=target;
            this.lock=lock;
            this.curr=curr;
            this.next=next;
        }
        @Override
        public void run(){
            while(count<max){
                try{
                    lock.lock();
                    if(count%flag!=target)
                        curr.await();
                    if(count<max){
                        count++;
                        System.out.println("线程"+name+"执行完毕,现在的count值为："+count);
                    }
                    next.signal();
                } catch(Exception e){
                    e.printStackTrace();
                } finally {
                    lock.unlock();
                }

            }
        }
    }
}

第二种解法：解法来源

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class Main {

	public static void main(String[] args){
    	
    	Thread t1 = new thread1();
    	Thread t2 = new thread2();
    	Thread t3 = new thread3();
    	// 使用 单个任务的线程池来实现。保证线程的依次执行
    	ExecutorService executor = Executors.newSingleThreadExecutor();
    	executor.submit(t1);
    	executor.submit(t2);
    	executor.submit(t3);
    	// 关闭线程池
    	executor.shutdown();
    }
}