DAY15

1.线程：

2.继承Thread类:

/**
 * 继承thread类进行多线程
 * @author Daniel
 *
 */
public class TestThread extends Thread{
	@Override
	public void run() {
		System.out.println("多线程运行的代码");
		for(int i = 0; i < 5; i ++) {
			System.out.println("这是多线程的逻辑代码" + i);
		}
	}
}

public class Test {
	public static void main(String[] args) {
		Thread t0 = new TestThread();
		t0.start();//启动线程
		System.out.println("------------");
		System.out.println("------------");
		System.out.println("--------------");
		/**
		 * 多次运行main方法后
		 * main方法中打印的三行
		 * 像两条河流一样，main和run各走各的
		 * 多线程的异步
		 */
	}
}

3.实现runnable接口：

/**
 * 实现runnable接口方式实现多线程
 * @author Daniel
 *
 */
public class TestRunnable implements Runnable{
	@Override
	public void run() {
		System.out.println(Thread.currentThread().getName() + "多线程运行的代码");
		for(int i = 0; i < 5; i ++) {
			System.out.println("这是多线程的逻辑代码" + i);
		}
	}
}

//		Thread t2 = new Thread(new TestRunnable());
//		t2.start();
		Thread t3 = new Thread(new TestRunnable(), "t-1");
		t3.start();
		System.out.println("------------");
		System.out.println("------------");
		System.out.println("--------------");

4.上述两个方法的区别：

5.Thread类的方法：

public class Test1 {
	public static void main(String[] args) {
		TestRun run0 = new TestRun();
		TestRun run1 = new TestRun();

		Thread t0 = new Thread(run0);
		Thread t1 = new Thread(run1);
		
		t0.start();
		t1.start();
		System.out.println(t0.getName());
		System.out.println(t1.getName());
		/**
		 * 线程的优先级，就是那个线程大概率被执行
		 * 用数字1-10表示，数字越大，优先级越高，默认优先级是5
		 */
//		t0.setPriority(1);//设置优先级
//		System.out.println("t0优先级：" + t0.getPriority());//获取线程优先级
		
		System.out.println("------------1");
		System.out.println("------------2");
		try {
			t0.join();
			/**
			 * 专业的说法
			 * 阻塞当前的main方法
			 */
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		t1.sleep();
		System.out.println("------------3");
	}
}

class TestRun implements Runnable{
	int count = 0;
	@Override
	public void run() {
		System.out.println(Thread.currentThread().getName() + ":Runnable多线程运行的代码");
		for(int i = 0; i < 5; i++) {
			if(i % 2 == 0) {
				Thread.yield();//线程让步
			}
			
			count ++;
			System.out.println(Thread.currentThread().getName() + ":这是Runnable多线程的逻辑代码" + count);
		}
	}
}

6.线程的生命周期：

7.线程的同步和死锁：

	public class Test2 {
		public static void main(String[] args) {
			//定义账户对象
			Acount a = new Acount();
			
			//多线程对象
			User u_vx = new User(a, 2000);
			User u_ali = new User(a, 2000);
	
			Thread vx = new Thread(u_vx,"微信");
			Thread ali = new Thread(u_ali,"支付宝");
			
			vx.start();
			ali.start();
		}
	}
	
	class Acount{
		public static int money = 3000;
		/**
		 * 判断钱够不够
		 * 多线程调用就会出问题
		 * 线程共享资源时，一个线程未完毕，另一个又开始执行
		 * 解决方法：先让一个线程结束，另一个再执行
		 * 通过synchronized关键字
		 * @param m
		 */
		public synchronized void drawing(int m) {
			String name = Thread.currentThread().getName();
			if(money < m) {
				System.out.println(name + "操作，账户金额不足" + money);
			}else {
	
				System.out.println(name + "操作" + "账户内原有金额：" + money );
				System.out.println(name + "操作" + "取款金额：" + m );
				
				money = money - m;
				System.out.println(name + "操作" +"提款后余额：" + money);
			}
			
			public synchronized void drawing1(int m) {
				String name = Thread.currentThread().getName();
				if(money < m) {
					System.out.println(name + "操作，账户金额不足" + money);
				}else {
	
					System.out.println(name + "操作" + "账户内原有金额：" + money );
					System.out.println(name + "操作" + "取款金额：" + m );
					
					money = money - m;
					System.out.println(name + "操作" +"提款后余额：" + money);
				}
	
			
		}
	}
	
	class User implements Runnable{
		Acount acount;
		int money;
		public User(Acount acount,int money) {
			this.acount = acount;
			this.money = money;
		}
		@Override
		public void run() {
	//		acount.drawing(money);
			if(Thread.currentThread().getName().equals("vx")) {
				acount.drawing(money);
			}else {
				acount.drawing1(money);
			}
		}
	}

8.线程的通信：

public synchronized void drawing1(int m,Acount a) {
			String name = Thread.currentThread().getName();
			if(name.equals("vx")){
				try {
					a.wait();//睡眠
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
			if(money < m) {
				System.out.println(name + "操作，账户金额不足" + money);
			}else {

				System.out.println(name + "操作" + "账户内原有金额：" + money );
				System.out.println(name + "操作" + "取款金额：" + m );
				
				money = money - m;
				System.out.println(name + "操作" +"提款后余额：" + money);
			}
			
			if(name.equals("ali")){
				try {
					a.notify();//唤醒当前优先级最高的
					a.notifyAll();//唤醒当前所有进程
				} catch (Exception e) {
					e.printStackTrace();
				}
			}

		
	}
}

9.生产者和消费者经典问题：

/**
 * 生产者与消费者
 * @author Daniel
 *
 */
public class Test3 {
	public static void main(String[] args) {
		final Clerk c = new Clerk();
		//消费时不生产，生产时不消费
		//生产者
		new Thread(new Runnable() {
			
			@Override
			public void run() {
				synchronized (c) {
					while(true) {//无限生产次数
						if(c.productNum == 0) {//产品数为0，开始生产
							System.out.println("产品数为0，开始生产");
							while(c.productNum < 4) {
								c.productNum ++;//增加库存
								System.out.println("库存" + c.productNum);
							}
							System.out.println("产品数为：" + c.productNum +",结束生产");
							c.notify();//唤醒消费者
						}else {
							try {
								c.wait();//生产者线程等待
							} catch (InterruptedException e) {
								e.printStackTrace();
							}
						}
					}
				}
			}
		},"生产者").start();;
		
		//消费者
		new Thread(new Runnable() {
			
			@Override
			public void run() {
				synchronized (c) {
					while(true) {//无限消费次数
						if(c.productNum == 4) {//产品数为4，开始消费
							System.out.println("产品数为4，开始消费");
							while(c.productNum > 0) {
								c.productNum--;
								System.out.println("库存" + c.productNum);
							}
							System.out.println("产品数为：" + c.productNum +",结束消费");
							c.notify();//唤醒生产者
						}else {
							try {
								c.wait();//消费者线程等待
							} catch (InterruptedException e) {
								e.printStackTrace();
							}
						}
					}
				}
			}
		},"消费者").start();;
	}
}

class Clerk{
	public static int productNum = 0;
	
}