java 多线程的学习总结

参考文章：https://blog.csdn.net/carson0408/article/details/79430813

模拟军队

军队的攻击方式

//军队线程
//模拟作战双方的行为
public class ArmyRunnable implements Runnable {
	//volatile保证了线程可以正确的读取其他线程写入的值()
	//可见性 可以参考ref JMM，happens-before原则
	volatile boolean keepRunning=true;
	

	@Override
	public void run() {
		while(keepRunning) {
			//发动5连击
			for(int i=0;i<5;i++){
				//获取当前线程的名称Thread.currentThread().getName()
				System.out.println(Thread.currentThread().getName()+"进攻对方["+i+"]次");
				//让出了处理器时间，下次该谁进攻还不一定呢！每次for循环完
				Thread.yield();
			}
		}
		System.out.println(Thread.currentThread().getName()+"结束了战斗");

	}

}

两支军队的整个攻击场景

//声明Stage类，继承Thread，表明它是一个线程
public class Stage extends Thread {
	
	public void run() {
		System.out.println("环境观看军队线程");
		//观众等待，5秒钟
		try {
			Thread.sleep(5000);
		} catch (InterruptedException e2) {
			// TODO Auto-generated catch block
			e2.printStackTrace();
		}
		//战争大幕徐徐拉开
		System.out.println("隋朝末年...");
		//隋朝军队
		ArmyRunnable armyTaskOfSuiDynasty=new ArmyRunnable();
		//起义军队
		ArmyRunnable armyTaskOfRevolt=new ArmyRunnable();
		
		//使用Runnable接口创建线程
		//隋朝军队线程
		Thread  armyOfSuiDynasty=new Thread(armyTaskOfSuiDynasty,"隋朝军队");
		//起义军队线程
		Thread  armyOfRevolt=new Thread(armyTaskOfRevolt,"起义军队");
		//启动军队作战
		armyOfSuiDynasty.start();
		armyOfRevolt.start();
		//舞台定义休眠为50毫秒，每次
		try {
			Thread.sleep(50);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		System.out.println("正当双方激战正酣，半路杀出了个程咬金");
		Thread mrCheng=new KeyPersonThread();
		mrCheng.setName("Mr.程咬金");
		System.out.println("程咬金的理想就是结束战争，天下太平");
		//军队停止作战
		armyTaskOfSuiDynasty.keepRunning=false;
		armyTaskOfRevolt.keepRunning=false;
		//停战2秒钟
		try {
			Thread.sleep(2000);
		} catch (InterruptedException e1) {
			// TODO Auto-generated catch block
			e1.printStackTrace();
		}
		//关键人物
		mrCheng.start();
		//万众瞩目，所有线程等待程咬金线程完成历史使命
		try {
			mrCheng.join();
		} catch (InterruptedException e1) {
			// TODO Auto-generated catch block
			e1.printStackTrace();
		}
		System.out.println("战争结束");
		System.out.println("谢谢观看");
		try {
			armyOfRevolt.join();
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		
	}
	
	//运行
	public static void main(String[] args) {
		new Stage().start();
	}

 关键人物的介入

public class KeyPersonThread extends Thread {

	public void run() {
	System.out.println(Thread.currentThread().getName()+"开始了战斗");
	//关键人物可以十连击攻击
	for(int i=0;i<10;i++){
		System.out.println(Thread.currentThread().getName()+"左突右杀，攻击随军...");
	}
	System.out.println(Thread.currentThread().getName()+"结束了战斗");
	}
}

最后结果

线程之间的交互

import java.util.concurrent.locks.*;
/**
 * void wait():让占用了这个同步对象的线程，临时释放当前的占用，并且等待。
 * @author ZQQ
 *
 */
	public class Student {
		public int k=0;
		public int total;
		public int perMonth;
		public String name;
		Lock lock=new ReentrantLock();
		public synchronized void saveMoney(Student s) {
			// TODO Auto-generated method stub
			while(total>=2000)
			{
				try
				{
					this.wait();
				}
				catch(InterruptedException e) {
					e.printStackTrace();
				}
			}
			s.total=s.total+2*(s.perMonth);
			System.out.println(s.name+"存了"+2*s.perMonth+"当前总共拥有"+s.total+"元");
			this.notify();//唤醒那些等待着取钱的过程，可以醒过来了。
			
			
		}
		public synchronized void getMoney(Student s)
		{
			while(total<=0)
			{
				try
				{
					this.wait();//让占有this的取钱过程，暂时释放对this的占有，并等待，等待其它线程的调用同步对象的notify方法来唤醒它。
				}
				catch(InterruptedException e) {
					e.printStackTrace();
				}
			}
	 
			s.total=s.total-s.perMonth;
			System.out.println(s.name+"取了"+s.perMonth+"当前总共拥有"+s.total+"元");	
			this.notify();
	 
	 
		}
		
}

线程交互实现

public class RunnableTest {
	 
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		final Object obj=new Object();
		final Student s=new Student();
		final Student jack=new Student();
		s.total=1000;
		s.perMonth=200;
		s.name="Tom";
		System.out.println("Tom最开始拥有"+s.total+"元");
		Thread[] save=new Thread[6];
		Thread[] get=new Thread[10];
		for(int i=0;i<10;i++)
		{
			Thread t1= new Thread(){
	            public void run(){
	            	
	            	
	            	s.getMoney(s);;
	            	//中断1秒钟
	        		try {
	        			Thread.sleep(1000);;
	        		}
	        		catch(InterruptedException e) {
	        			e.printStackTrace();
	        		}
	            	
	            }
	        };
	        //启动线程
	        t1.start();
	        get[i]=t1;
		}
		
		for(int i=0;i<6;i++)
		{
			Thread t2= new Thread(){
	            public void run(){
	            	
	            	s.saveMoney(s);
	            	
	            	
	        		try {
	        			Thread.sleep(1000);;
	        		}
	        		catch(InterruptedException e) {
	        			e.printStackTrace();
	        		}
	            	
	            }
	        };
	        t2.start();
	        save[i]=t2;
		}
		//等待线程结束
		for(Thread t:save)
		{
			try
			{
				t.join();
				
			}
			catch(InterruptedException e)
			{
				e.printStackTrace();
			}
 
		}
		//等待线程结束
		for(Thread t:get)
		{
			try
			{
				t.join();
			}
			catch(InterruptedException e)
			{
				e.printStackTrace();
			}
 
		}
		
		System.out.println("最后Tom总共拥有"+s.total+"元");
		
	}
 
}

线程交互最后结果