多线程知识点整理

超级无敌瘦瘦瘦
于 2022-07-24 14:53:22 发布
阅读量196
点赞数
分类专栏： java 文章标签： java
本文链接：https://blog.csdn.net/qq_37141187/article/details/125959248
版权
java 专栏收录该内容
7 篇文章 0 订阅
订阅专栏
线程的概念、使用、声明周期等知识点整理
多线程
1、基本概念：程序、进程、线程
/**
 * 1、程序、进程、线程的基本概念：
 * 程序：指一段静态的代码；（为什么说是静态呢，还没有加载到内存中，CPU还没有参与运算）
 * 进程：是程序的一次执行过程，或是正在运行的一个程序；
 * 线程：进程可进一步细化为线程，是一个程序内部的一条执行路径，
 *     ①若一个进程同一时间并行执行多个线程，就是支持多线程的；
 *     ②线程作为调度和执行的单位，每个线程拥有独立的运行栈和程序计数器(pc)，线程切换的开销小；
 *     ③但多个线程操作共享的系统资源可能会带来安全隐患。
 *      
 * 内存区域：
 * 虚拟机栈和程序计数器是一个线程各自一份，方法区和堆是一个进程一份；
 * （一个进程里有多个线程）
 * 
 * 2、单核cpu和多核cpu的理解：
 *   ①单核CPU，其实就是一种假的多线程，因为在一个时间单元内，也只能执行
 *     一个线程的任务。但是因为CPU时间单元特别短，因此感觉不出来。
 *   ②如果是多核的话，才能更好的发挥多线程的效率。（现在服务器都是多核的）
 *   ③一个java应用程序java.exe，其实至少有三个线程：main()主线程，gc()
 *    垃圾回收线程，异常处理线程。当然如果发生异常，会影响主线程。
 *   
 * 3、并行与并发：
 *   并行：多个CPU同时执行多个任务。比如：多个人同时做不同的事情。
 *   并发：一个CPU（采用时间片）同时执行多个任务。比如：秒杀、多个人做同一件事情。
 *     （看似是同时，其实是CPU快速的切换这几个不同的任务）
 *     
 * 4、使用多线程的优点：
 *   ①提高应用程序的响应。对图形化界面更有意义，可增强用户体验。（譬如360 ，可以一边体检、一边木马查杀）
 *   ②提高计算机系统CPU的利用率；
 *   ③改善程序结构。将既长又复杂的进程分为多个线程，独立运行，有利于理解和修改。
 * 
 * 5、何时需要多线程：
 *   ①程序需要同时执行两个或多个任务；
 *   ②程序需要实现一些需要等待的任务时，如用户输入、文件读写操作、网络操作、搜索等。
 *   ③需要一些后台运行的程序时。
 * 
 * @author qctc
 *
 */
2、线程的创建和使用
（1）创建多线程的方式一：继承于Thread类
/**
 * 创建多线程的方式一：继承于Thread类
 * 1、创建一个继承于Thread类的子类;
 * 2、重写Thread类的run()方法-->将此线程执行的操作声明在run()方法中;
 * 3、创建Thread类的子类的对象;
 * 4、通过此对象调用strart()方法;
 * 
 * 例子：遍历100以内的所有的偶数
 *
 */
//1、创建一个继承于Thread类的子类
class MyThread extends Thread{
	//2、重写Thread类的run()方法
	@Override
	public void run() {
		for(int i=0;i<=100;i++) {
			if(i%2==0) {
				System.out.println(getName()+":"+i);
			}
		}
	}
}
public class ThreadDemo{
	public static void main(String[] args) {
		//3、创建Thread类的子类的对象
		MyThread t1 = new MyThread();
		//4、通过此对象调用strart()方法:①启动当前线程②调用当前线程的run()方法；
		t1.start();
		//问题一：我们不能通过直接调用run()的方式启动线程
		//t1.run();//只是体现对象调方法，没有开启一个新的线程
		
		//问题二：再启动一个线程，遍历100以内的偶数。不可以还让已经start()的线程去执行，会报java.lang.IllegalThreadStateException异常。
		//t1.start();
		//需要重新创建一个线程的对象
		MyThread t2 = new MyThread();
		t2.start();
		
		//如下操作仍然是在main线程中执行的。
		for(int i=0;i<=100;i++) {
			if(i%2==0) {
				System.out.println(Thread.currentThread().getName()+":"+i+"----");
			}
		}
	}
}

（2）创建多线程的方式二：实现Runnable接口
/**
 * 创建多线程的方式二：实现Runnable接口
 * 1、创建一个实现了Runnable接口的类
 * 2、实现Runnable中的抽象方法：run()
 * 3、创建实现类的对象
 * 4、将此对象作为参数传递到Thread类的构造器中，创建Thread类的对象
 * 5、通过Thread类的对象调用start()
 * 
 * 
 * 比较创建线程的两种方式：
 * 开发中：优先选择：实现Runnable接口的方式
 * 原因: 1、实现的方式没有类的单继承性的局限性
 * 	    2、实现的方式更适合来处理多个线程有共享数据的情况
 * 
 * 联系：public class Thread implements Runnable
 * 相同点：两种方式都需要重写run()，将线程要执行的逻辑声明在run()中。
 * 
 * 线程通信：wait()、notify()、notifyAll()：此三个方法定义在Object类中的。
 * 
 * 补充：线程的分类
 * 一种是守护线程，一种是用户线程。
 * （例如：垃圾回收机制就是守护线程，main 就是用户线程）
 * 
 * @author qctc
 *
 */
//1、创建一个实现了Runnable接口的类
class MThread implements Runnable{
	//2、实现Runnable中的抽象方法：run()
	@Override
	public void run() {
		// TODO Auto-generated method stub
		for(int i=0;i<=100;i++) {
			if(i%2==0) {
				System.out.println(Thread.currentThread().getName()+":"+i);
			}
		}
	}
}

public class DemoRunable {
	public static void main(String[] args) {
		//3、创建实现类的对象
		MThread mt = new MThread();
		//4、将此对象作为参数传递到Thread类的构造器中，创建Thread类的对象
		Thread t1 = new Thread(mt);
		t1.setName("线程一");
		//5、通过Thread类的对象调用start():①启动线程②调用当前线程的run()-->调用了Runnable类型的target的run()。
		t1.start();
		
		//再启动一个线程，遍历100以内的偶数
		Thread t2 = new Thread(mt);
		t2.setName("线程二");
		t2.start();
	}
}
Thread类的常用方法：
/**
 * 测试Thread类的常用方法：
 * 1、start():启动当前线程；调用当前线程的run()；
 * 2、run():通常需要重写Thread类中的此方法，将创建的线程要执行的操作声明在此方法中；
 * 3、currentThread():静态方法，返回执行当前代码的线程；
 * 4、getName():获取当前线程的名字；
 * 5、setName():设置当前线程的名字；
 * 6、yield():线程让步。释放当前CPU的执行权；（有可能在下一刻又分配到当前的线程）
 *   大白话就是：释放当前线程使用的cpu的执行权，之后有可能CPU还会分配给当前线程。
 *   （1）譬如：释放当前CPU的执行权（当前线程：新的线程1：：）
        新的线程1：：：--------20
	    主线程--------19
	 （1）譬如：在下一刻又分配到当前的线程（当前线程：新的线程1：：）
	    新的线程1：：：--------0
	    新的线程1：：：--------2
   7、join():在线程a中调用线程b的join()，此时线程a就进入阻塞状态，直到线程b完全执行完之后，线程a才结束阻塞状态。（之后就看CPU啥时候给分配资源了）
 * 8、stop():已过时。强制线程生命期结束，不推荐使用
 * 9、sleep(long millis):(指定时间：毫秒数)
 *     让当前线程“睡眠”指定的毫秒数，在指定的毫秒时间内，当前线程是阻塞状态。
 * 	   （令当前活动线程在指定时间段内放弃对CPU控制，使其他线程有机会被执行，时间到后重排队。）
 * 
 * 10、boolean isAlive():返回boolean，判断线程是否还活着。
 * 
 * 
 * 
 * 线程的优先级：
 * 1、线程的优先级等级
 *  （1）MAX_PRIORITY:10
 *  （2）MIN_PRIORITY:1
 *  （3）NORM_PRIORITY:5（通常情况下默认优先级是5）
 * 2、如何获取和设置当前线程的优先级：
 * 	（1）getPriority():返回线程优先级
 * 	（2）setPriority(int newPriority):改变线程的优先级
 * 
 * 说明：高优先级的线程要抢占低优先级线程CPU的执行权。但是只是从概率上讲，高优先级的线程高概率的情况下
 * 被执行。并不意味着只有当高优先级的线程执行完以后，低优先级的线程才执行。
 * 3、说明
 * 	（1）线程创建时继承父线程的优先级
 * 	（2）低优先级只是获得调度的概率低，并非一定是在高优先级线程之后才被调用。
 * 
 * @author qctc
 *
 */
匿名子类创建多线程的方式：
使用Thread的方式
//创建Thread类的匿名子类的方式
		new Thread() {
			@Override
			public void run() {
				for(int i=0;i<=100;i++) {
					if(i%2==0) {
						System.out.println(Thread.currentThread().getName()+":"+i);
					}
				}
			}
		}.start();

使用Runnable的方式
new Thread(new Runnable() {
	@Override
	public void run() {
		...
	}	
}).start();
3、线程的生命周期



线程的同步
同步代码块：窗口卖票举例
实现Runnable接口
/**
 * 实现Runnable接口----->同步代码块
 * 例子：创建三个窗口卖票，总票数为100张。使用实现Runnable接口的方式。
 * 
 * 1、问题：卖票过程中，出现了重票、错票 -->出现了线程的安全问题
 * 2、问题出现的原因：当某个线程操作车票的过程中，尚未操作完成时，其他线程参与进来，也操作车票。
 * 3、如何解决：当一个线程a在操作ticket的时候，其他线程不能参与进来，直到线程a操作完ticket时，其他线程才可以开始操作ticket。这种情况即使线程a出现了阻塞，也不能改变。
 * 4、在java中，我们通过同步机制，来解决线程的安全问题。      
 * 	
 * 	方式一：同步代码块
 * 	synchronized(同步监视器){
 * 		//需要被同步的代码
 * 	}    
 * 	说明：1、操作共享数据的代码，即为需要被同步的代码；
 * 		  2、共享数据：多个线程共同操作的变量。比如：ticket就是共享数据。
 * 		  3、同步监视器，俗称：锁。任何一个类的对象，都可以充当锁。
 * 			要求：多个线程必须要共用同一把锁。
 补充：
（1）在实现Runnable接口创建多线程的方式中，我们可以考虑用this充当同步监视器。
（2）在继承Thread类创建多线程的方式中，慎用this充当同步监视器，考虑使用当前类充当同步监视器。
 * 	
 *  方式二：同步方法。
 *  如果操作共享数据的代码完整的声明在一个方法中，我们不妨将此方法声明同步的。
 * 
 * 5、同步的方式，解决了线程的安全问题。-->好处
 *   操作同步代码时，只能有一个线程参与，与其他线程等待。相当于是一个单线程的过程，效率低。-->局限性
 * @author qctc
 *
 */
class Window1 implements Runnable{
	
	private int ticket = 100;
	//Object obj = new Object();
	Dog dog = new Dog();//任何一个类的对象，都可以充当锁。
	
	@Override
	public void run() {
		while(true) {
			synchronized(this){//此时的this:唯一的window1对象 
//方式二：synchronized(dog) {
				if(ticket>0) {
					try {
						Thread.sleep(100);
					} catch (InterruptedException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
					System.out.println(Thread.currentThread().getName()+"卖票，票号为：" + ticket);
					ticket--;
				}else{
					break;
				}
			}
		}
	}
}
public class WindowTest1 {
	public static void main(String[] args) {
		Window1 w = new Window1();
		
		Thread t1 = new Thread(w);
		Thread t2 = new Thread(w);
		Thread t3 = new Thread(w);
		
		t1.setName("窗口1");
		t2.setName("窗口2");
		t3.setName("窗口3");
		
		t1.start();
		t2.start();
		t3.start();
	}
}
class Dog{
	
}

继承Thread类
class Window2 extends Thread {
	private static int ticket = 100;
	private static Object obj = new Object();
	
	@Override
	public void run() {
		while(true) {
			//正确的
			//synchronized(obj) {
			//Class clazz = Window2.class,Window2.class只会加载一次
			synchronized(Window2.class) {
				//错误的方式：this代表着t1,t2,t3三个对象
				//synchronized(this) {
				if(ticket>0) {
					try {
						Thread.sleep(100);
					} catch (InterruptedException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
					System.out.println(getName()+"，票号："+ticket);
					ticket--;
				}else if(ticket==0){
					break;
				}
			}
		}
	}
}

public class WindowTest2 {
	public static void main(String[] args) {
		Window2 t1 = new Window2();
		Window2 t2 = new Window2();
		Window2 t3 = new Window2();
		
		t1.setName("窗口1");
		t2.setName("窗口2");
		t3.setName("窗口3");
		
		t1.start();
		t2.start();
		t3.start();
	}
}
同步方法：
实现Runnable接口
class Window1_1 implements Runnable{
	
	private int ticket = 100;
	Object obj = new Object();//任何一个类的对象，都可以充当锁。
	//Dog dog = new Dog();
	
	@Override
	public void run() {
		while(true) {
			show();
		}
	}
	public synchronized void show() {//同步监视器：this
		if(ticket>0) {
			try {
				Thread.sleep(100);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			System.out.println(Thread.currentThread().getName()+"卖票，票号为：" + ticket);
			ticket--;
		}
	}
}
2）继承Thread类
/**
 * 继承Thread类----->同步方法
 * 使用同步方法处理继承Thread类的方式中的线程安全问题
 * 
 * 关于同步方法的总结：
 * 1、同步方法仍然涉及到同步监视器，只是不需要我们显式的声明。
 * 2、非静态的同步方法，同步监视器是：this
 *    静态的同步方法，同步监视器是：当前类本身
 * @author qctc
 */
private static synchronized void show() {//同步监视器：Window2_1.class
	//private synchronized void show(){同步监视器 t1,t2,t3 此种方式是错误的
		if(ticket>0) {
			try {
				Thread.sleep(100);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			System.out.println(Thread.currentThread().getName()+"，票号："+ticket);
			ticket--;
		}
	}
Lock锁：
解决线程安全问题的方式三：Lock锁--->jdk5.0新增
/**
 * 解决线程安全问题的方式三：Lock锁--->jdk5.0新增
 * 
 * 1、面试题：synchronized 与 lock的异同？
 *   相同：二者都可以解决线程安全问题
 *   不同：synchronized机制在执行完相应的同步代码以后，自动的释放同步监视器;
 *       lock需要手动的启动同步lock(),同时结束同步也需要手动的实现unlock();
 
 *  面试题：如何解决线程安全问题？有几种方式
 *  1、如果说两种方式：synchronized 和 lock 方式
 *  2、如果说三种方式：synchronized的同步代码块、同步方法和lock方式。
 *  
 *  
 * @author qctc
 *
 */
class Window implements Runnable{
	private int ticket = 100;
	//1、实例化ReentrantLock
	private ReentrantLock lock = new ReentrantLock();

	@Override
	public void run() {
		while(true) {
			//将需要同步的代码放到try中
			try {
				//2、调用锁定方法：lock()
				lock.lock();
				
				if(ticket>0) {
					
					try {
						Thread.sleep(100);
					} catch (InterruptedException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
					System.out.println(Thread.currentThread().getName()+"卖票，票号为："+ticket);
					ticket--;
				}else {
					break;
				}
			}finally {
				//3、调用解锁方法：unlock()
				lock.unlock();
			}
		}
	}
}
public class LockDemo {
	public static void main(String[] args) {
		Window w = new Window();
		Thread t1 = new Thread(w);
		Thread t2 = new Thread(w);
		Thread t3 = new Thread(w);
		
		t1.setName("窗口1");
		t2.setName("窗口2");
		t3.setName("窗口3");
		
	    t1.start();
	    t2.start();
	    t3.start();
	}
}

线程的通信

（1）涉及到的三个方法
/**
 * 线程通信的例子：使用两个线程打印1-100。线程1，线程2, 交替打印
 * 
 * 涉及到的三个方法：
 * wait():一旦执行此方法，当前线程就进入阻塞状态，并释放同步监视器。
 * notify();一旦执行此方法，就会唤醒被wait的一个线程，如果有多个线程被wait，虎牙唤醒优先级高的那个。
 * notifyAll():一旦执行此方法，就会唤醒所有被wait的线程。
 * 
 * 注意项说明：
 * 1、wait()、notify()、notifyAll()三个方法必须使用在同步代码块或同步方法中。
 * 2、wait()、notify()、notifyAll()三个方法的调用者必须是同步代码块或同步方法中的同步监视器，
 * 		否则，会出现java.lang.IllegalMonitorStateException异常
 * 例如：
 * synchronized(this) {
				notify();
				。。。
				wait()
				}
	或者
	synchronized(obj) {
				obj.notify();
				。。。
				obj.wait()
				}
 * 
 * 3、wait()、notify()、notifyAll()三个方法是定义在java.lang.Object类中。
 * 
 * 面试题：sleep()和wait()的异同？
 * 1、相同点：一旦执行方法，都可以使得当前的线程进入阻塞状态。
 * 2、不同点：1）两个方法声明的位置不同：Thread类声明sleep(),Object声明wait();
 *          2）调用的要求不同：sleep()可以在任何需要的场景下调用；wait()必须使用在同步代码块或同步方法中；
 *          3）关于是否释放同步 监视器：如果两个方法都使用在同步代码块或同步方法中，sleep()不会释放锁（同步监视器），wait()会释放锁。
 * 
 * 
 * @author qctc
 *
 */
class Number implements Runnable{
	private int number = 1;
	private Object obj = new Object();

	@Override
	public void run() {
		while(true) {
			synchronized(obj) {
				obj.notify();
				if(number<=100) {
					try {
						Thread.sleep(10);
					} catch (InterruptedException e1) {
						// TODO Auto-generated catch block
						e1.printStackTrace();
					}
					System.out.println(Thread.currentThread().getName()+":"+number);
					number++;
					
					try {
						//使得调用如下wait()方法的线程进入阻塞状态
						obj.wait();
					} catch (InterruptedException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
					
				}else {
					break;
				}
			}
		}
	}
}

public class CommunicationTest {
	public static void main(String[] args) {
		Number number = new Number();
		Thread t1 = new Thread(number);
		Thread t2 = new Thread(number);
		
		t1.setName("线程1");
		t2.setName("线程2");

		t1.start();
		t2.start(); 
	}
}
jdk5.0新增线程创建方式
创建线程的方式三：实现Callable接口。--->jdk 5.0新增
/**
 * 创建线程的方式三：实现Callable接口。--->jdk 5.0新增
 * 
 * 如何理解实现Callable接口的方式创建多线程比实现Runnable接口创建多线程方式强大？
 * 1、call()可以有返回值的。
 * 2、call()可以抛出异常，被外面的操作捕获，获取异常的信息。
 * 3、Callable是支持泛型的。
 * 
 * @author qctc
 *
 */
//1、创建一个实现Callable的实现类
class NumThread implements Callable{
	//2、实现call方法，将次线程需要执行的操作声明在call()中;
	@Override
	public Object call() throws Exception {
		int num = 0;
		for(int i = 0;i<=100;i++) {
			if(i%2==0) {
				System.out.println("i::"+i);
				num+=i;
			}
		}
		return num;
	}
}
public class ThreadNew {
	public static void main(String[] args) {
		//3、创建Callable接口实现类的对象（t1）
		NumThread t1 = new NumThread();
		//4、将此Callable接口实现类的对象作为传递到FutureTask的构造器中，创建FutureTask的对象
		FutureTask futureTask = new FutureTask(t1);
		//5、将FutureTask的对象作为参数传递到Thread类的构造器中，创建Thread对象，并调用start()方法。
	    new Thread(futureTask).start();
		
		try {
			//6、获取Callable中call方法的返回值（不需要返回值可以不用这一步，直接返回null）
			//get()返回值即为FutureTask的构造器参数Callable实现类重写call()的返回值。
			//如果想要用到返回值就调用get()方法，如果不需要就可以不调用
			Object sum = futureTask.get();
			System.out.println(sum);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (ExecutionException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		
//		try {
//			System.out.println("和："+t1.call());
//		} catch (Exception e) {
//			// TODO Auto-generated catch block
//			e.printStackTrace();
//		}
	}
}
创建线程的方式四：使用线程池
/**
 * 创建线程的方式四：使用线程池
 * 
 * 好处：
 * 1、提高响应速度（减少了创建新线程的时间）
 * 2、降低资源消耗（重复利用线程池中线程，不需要每次都）
 * 3、便于线程管理
 *  	corePoolSize：核心池的大小
 *  	maximumPoolSize：最大线程数
 *  	KeepAliveTime：线程没有任务时最多保持多长时间后会终止
 *  
 *  面试题：创建多线程有几种方式？四种
 * @author qctc
 *
 */
class NumberThread implements Runnable{

	@Override
	public void run() {
		for(int i=0;i<=100;i++) {
			if(i%2==0) {
				System.out.println(Thread.currentThread().getName()+":"+i);
			}
		}
	}
}
public class ThreadPool {
	public static void main(String[] args) {
		//1、提高指定线程数量的线程池
		ExecutorService service = Executors.newFixedThreadPool(10);
		ThreadPoolExecutor service1 = (ThreadPoolExecutor) service;
		//设置线程池的属性
//		service1.setCorePoolSize(15);
//		service1.setKeepAliveTime(0, null);
		
		//2、执行指定的线程的操作，需要提供实现Runnable接口或Callable接口实现类的对象
		service.execute(new NumberThread());//适合适用于Runnable
//		service.submit();//适合适用于Callable
		
		//3、关闭连接池
		service.shutdown();
	}
}
例题：
使用同步机制将单例模式中的懒汉式改写为线程安全的
//单例模式-->懒汉模式
class Bank{
	private Bank() {}
	private static Bank instance = null;
	
	public static Bank getInstance() {
		//方式一：效率稍差
//		synchronized (Bank.class) {
//			if (instance == null) {
//				instance = new Bank();
//			}
//			return instance;
//		}
		// 方式二：效率更高
		if (instance == null) {
			synchronized (Bank.class) {
				if (instance == null) {
					instance = new Bank();
				}
			}
		}
		return instance;
	}
}
演示线程的死锁问题
/**
 * 演示线程的死锁问题
 * 
 * 1、死锁的理解：不同的线程分别占用对方需要的同步资源不放弃，
 * 都在等待对方放弃自己需要的同步资源，就形成了线程的死锁。
 * 
 * 2、说明：
 * ①出现死锁后，不会出现异常，不会出现提示，只是所有的线程都处于阻塞状态，无法继续
 * ②我们使用同步时，要避免出现死锁。
 * 
 * 3、解决方法：
 * ①专门的算法、原则
 * ②尽量减少同步资源的定义
 * ③尽量避免嵌套同步
 * 
 * @author qctc
 *
 */
public class DeadLocTest {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		StringBuffer s1 = new StringBuffer();
		StringBuffer s2 = new StringBuffer();
		
		new Thread() {
			@Override
			public void run() {
				synchronized(s1) {
					try {
						Thread.sleep(100);
					} catch (InterruptedException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
					s1.append("a");
					s2.append("1");
					synchronized(s2) {
						s1.append("b");
						s2.append("2");
						
						System.out.println(s1);
						System.out.println(s2);
					}
				}
			}
		}.start();
		
		new Thread(new Runnable() {

			@Override
			public void run() {
				// TODO Auto-generated method stub
				synchronized(s1) {
					try {
						Thread.sleep(100);
					} catch (InterruptedException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
					s1.append("c");
					s2.append("3");
					synchronized(s2) {
						s1.append("d");
						s2.append("4");
						
						System.out.println(s1);
						System.out.println(s2);
					}
				}
			}
			
		}).start();
	}
}

可能输出的结果：
ab
12
abcd
1234
或者
cd
34
cdab
3412
练习：银行账户
/**
 * 练习1：
 * 银行有一个账户。
 * 有两个储户分别向同一个账户存3000元，每次存1000，存三次。每次存完打印账户余额。
 * 
 * @author qctc
 *
 */
class Person implements Runnable{
	private int money = 0;

	@Override
	public void run() {
		synchronized(Person.class) {
			for(int i=0;i<3;i++) {
				try {
					Thread.sleep(1000);
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
				money +=1000;
				System.out.println(Thread.currentThread().getName()+"存钱之后账户余额为："+money);
			} 
		}
	}
}

public class ExerAcount {
	public static void main(String[] args) {
		Person p = new Person();
		Thread t1 = new Thread(p);
		Thread t2 = new Thread(p);
		
		t1.setName("第一个人");
		t2.setName("第二个人");
		
		t1.start();
		t2.start();
	}
}