JavaSE07

package day07;

import javax.management.RuntimeErrorException;

/**
 * 多线程并发安全问题：
 * 当多个线程并发运行操作统一数据是时，由于线程切换的时机不可控制，
 * 可能导致操作该数据时的过程未按照程序设计的执行时顺序运行导致
 * 操作出现混乱，严重时可能会导致系统瘫痪。
 * @author 臻冉
 *
 */
public class SycnDemo_01 {
	public static void main(String[] args) {
		Table table = new Table();
		
		Thread t1 = new Thread(){
			public void run(){
				while(true){
					int b = table.getBean();
					Thread.yield();//模拟线程切换
					System.out.println(getName()+":"+b);
				}
			}
		};
		
		Thread t2 = new Thread(){
			public void run(){
				while(true){
					int b1 = table.getBean();
					Thread.yield();//模拟线程切换
					System.out.println(getName()+":"+b1);
				}
			}
		};
		t1.start();
		t2.start();
	}
}

class Table{
	private int bean = 20;
	
	/*
	 * yield()方法作用是:暂停当前正在执行的线程对象（放弃当前拥有的CPU资源），
	 * 并执行其他线程
	 * 
	 * yield()让当前运行线程回到可运行状态，以允许具有相同优先级的其他线程
	 * 获得运行机会，但是有可能效果没用
	 */
	
	/*
	 * 当一个方法用synchronized修饰后，那么该方法变为“同步方法”多个线程
	 * 不能同时进入方法运行，而必须有顺序的一个一个运行这样就避免了并发安全问题
	 */
	public synchronized int getBean(){
		if(bean == 0){
			throw new RuntimeException("没有豆子了！");
		}
		Thread.yield();//模拟线程切换
		return bean--;
	}
}

package day07;
/**
 * 有效的缩小同步范围可以在保证并发安全的前提下尽可能提高并发效率
 * 
 * 同步块：
 * synchronized(同步监视器){
 * 		需要同步运行的代码片段
 * }
 * 同步块可以更灵活准确的锁定需要的同步运行的代码片段，
 * 这样可以有效缩小同步范围提高并发效率
 * 但是需注意，必须保证多个线程看到的同步监视器对象是“同一个”才可以
 * @author 臻冉
 *
 */
public class SycnDemo_02 {
	public static void main(String[] args) {
		Shop shop = new Shop();
		Thread t1 = new Thread(){
			public void run(){
				shop.buy();
			}
		};
		
		Thread t2 = new Thread(){
			public void run(){
				shop.buy();
			}
		};
		t1.start();
		t2.start();
	}
}
class Shop{
	public void buy(){
		try {
			Thread name = Thread.currentThread();
			System.out.println(name.getName()+"挑衣服");
			Thread.sleep(5000);
			synchronized (this) {
				System.out.println(name.getName()+"试衣服");
				Thread.sleep(5000);
			}
			
			System.out.println(name.getName()+"结账离开");
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	}
}

package day07;
/**
 * 互斥锁
 * 使用synchronized锁定多段代码，而锁的对象相同时，
 * 这些代码片段之间就是互斥锁，多个线程不能同时执行这些方法
 * @author 臻冉
 *
 */
public class SycnDemo_03 {
	public static void main(String[] args) {
		Boo b = new Boo();
			Thread t1 = new Thread(){
				public void run(){
					b.method01();
				}
			};
			
			Thread t2 = new Thread(){
				public void run(){
					b.method02();
				}
			};
			t1.start();
			t2.start();
		
	}
}

class Boo{
	Thread name = Thread.currentThread();
	public void method01(){
		try {
			System.out.println(name.getName()+"正在运行A方法");
			Thread.sleep(5000);
			System.out.println(name.getName()+"正在运行的A方法完毕！");
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		
	}
	
	
	public void method02(){
		try {
			System.out.println(name.getName()+"正在运行B方法");
			Thread.sleep(5000);
			System.out.println(name.getName()+"正在运行的B方法完毕！");
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		
	}
}

package day07;
/**
 *  死锁现象
 *  线程都保持着自己的锁，但是都等待对方来释放锁时，就出现了互相“僵持“的状况
 *  导致程序不会再继续向下运行
 * @author 臻冉
 *
 */
public class SycnDemo_04 {
	public static void main(String[] args) {
		Foo f = new Foo();
		Thread t1 = new Thread(){
			public void run(){
				f.mothed01();
			}
		};
		
		Thread t2 = new Thread(){
			public void run(){
				f.mothed02();
			}
		};
		t1.start();
		t2.start();
	}
}

class Foo{
	private Object synA = new Object();
	private Object synB = new Object();
	
	public  void mothed01(){
		
		try {
			synchronized(synA){
				System.out.println("我是方法1");
				Thread.sleep(2000);
				mothed02();
			}
			
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
	
	public  void mothed02(){
		
		try {
			synchronized(synB){
				System.out.println("我是方法2");
				Thread.sleep(2000);
				mothed01();
			}
			
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
}

package day07;
/**
 * 1、wait是object类中的方法，而sleep是Thread类中的方法
 * 、
 * @author 臻冉
 *
 */
public class DemoWait_05 {
	public static void main(String[] args) {
/*		Thread t = new My();
		Thread t2 = new My();
		Thread t3 = new My();
		t.start();
		t2.start();
		t3.start();*/
		
		Thread t = new My();
		Thread t2 = new My2();
		t.start();
		t2.start();
	}
}

class My extends Thread{
	public static StringBuilder value = new StringBuilder();
	public void run(){
		String name = Thread.currentThread().getName();
		synchronized (value) {
			for(int i=0;i<5;i++){
				try {
					value.wait(10000);		//完全释放锁
					//Thread.sleep(1000);		//不释放锁
					value.append("a");
					System.out.println(name+value.toString());
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
		}
	}
}

//唤醒wait状态
class My2 extends Thread{
	public void run(){
		synchronized (My.value) {
			for(int i=0;i<2;i++){
				try {
					Thread.sleep(2000);
					System.out.println("呵呵");
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
			My.value.notifyAll();//唤醒wait状态  All唤醒所有的
		}
		
		
	}
}

package day07;

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

/**
 * 线程池：
 * 线程池主要完工作：
 * 1、管理线程数量，由于每个线程会占用一定的内存，线程数量过多会导致内存占用
 * 		过大，还有一个问题就是CPU过度切换会导致程序出现“卡顿”；
 * 2、重用线程
 * @author 臻冉
 *
 */
public class ThreadPoolDemo_06 {
	public static void main(String[] args) {
		//创建一个线程池
		ExecutorService pool = Executors.newFixedThreadPool(2);
		
		for(int i=0;i<5;i++){
			Runnable runn = new Runnable(){
				public void run(){
					try {
						String name =Thread.currentThread().getName();
						System.out.println(name+"正在运行任务...");
						Thread.sleep(5000);
					} catch (InterruptedException e) {
						//e.printStackTrace();
						System.out.println("线程池中断...");
					}
				}
			};
			//将任务指派给线程池
			pool.execute(runn);
		}
		
		/*
		 * shutdown与shutdownNow都是停止线程池
		 * shutdown方法调用后，线程池不再接受新任务，会将已有的任务全部执行后停止
		 * 
		 * shutdownNow调用后，线程池会调用所有线程的中断方法后立刻停止
		 */
		pool.shutdownNow();
	}
}