什么是synchronized

public class ThreadLocalTest {
	class Person {
		String name = "zhangsan";
	}
	@Test
	public void threadLocal1() {
		ThreadLocal<Person> tl = new ThreadLocal<Person>();
		Person person = new Person();
		tl.set(person);
		new Thread(new Runnable() {
			@Override
			public void run() {
				System.out.println("新启线程"+tl.get());
			}
		}).start();
		System.out.println(tl.get());
		try {
			TimeUnit.SECONDS.sleep(2);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
}

public class ProducerAndConsumer {
	//有2个生产者线程、10个消费者线程，如果容器满了，则生产者暂停，如果容器空了，则消费者暂停
	final private LinkedList list = new LinkedList();
	final private int maxValue = 10;
	/**
	 * 生产者，按照要求：当容器满了，就停止。
	 */
	public synchronized void producer(Object o) {
		/**
		 * 最初的实现是用if，但是为什么又改成if而改成while呢：（这是一个坑，很容易掉里面）
		 * 	1.你想啊，如果此时，容器满了，然后第一个线程到这后，判断if逻辑，然后执行wait方法进行等待，并【释放当前对象锁】
		 *  2.然后cpu调起哪个线程，是随机选择的，如果此时，又调起了一个生产者线程，那么也执行到了这个wait方法。
		 *  3.目前已经有两个线程在wait这了，然后cpu执行消费者线程消费了1个，现在容器中还有9个，
		  *        然后消费者线程唤醒通过notifyall唤醒线程，唤醒了这两个生产者线程，那么：
		 *  	3.1 首先第一个生产者线程开始执行，从wait处开始往下执行，添加元素，容器又满了，释放锁
		 *  	3.2 然后第二个生产者线程开始执行，也是从wait处开始执行，因为使用的不是while循环，所以
		 *  		会直接往下执行，也就是添加元素，那么容器大小就不是10 个了。
		 *  4.所以，使用wait时的场景，99%都是与while循环配合使用
		 *  5.如果wait和notify不写在synchronized锁里面，会抛IllegalMonitorStateException异常，但是
		 *  	为什么必须在synchronized锁中呢，那么肯定会出现wait调用发生在调用notify之后的情况。[参考博客](https://www.cnblogs.com/set-cookie/p/8686218.html)
		 */
//		if(list.size()==maxValue) {
		while(list.size()==maxValue) {
			try {
				this.wait();
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
		list.add(o);
		//容器中有东西了，唤醒等待的线程线程进行消费（唤醒的线程中包括生产者线程和消费者线程），其主要目的是消费者线程
		this.notifyAll();
	}
	/**
	 * 消费者
	 */
	public  synchronized Object consumer() {
		while(list.size()==0) {
			try {
				this.wait();
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
		//我拿走东西了，唤醒等待的线程进行生产（唤醒的线程中包括生产者线程和消费者线程），其主要目的是生产者线程
		Object o = list.removeFirst();
		this.notifyAll();
		return o;
	}
	public static void main(String[] args) {
		ProducerAndConsumer pcTest = new ProducerAndConsumer();
		//启动消费者线程
		for(int i=0;i<10;i++) {
			new Thread(()->{
				for(int j=0;j<10;j++) {
					System.out.println(pcTest.consumer()+"aa");
				}
			},"c"+i) .start();
		}
		try {
			TimeUnit.SECONDS.sleep(2);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		//启动生产者线程
		for(int i=0;i<2;i++) {
			new Thread(()->{
				for(int j=0;j<30;j++) {
					pcTest.producer(Thread.currentThread().getName());
				}
			},"p"+i) .start();
		}
	}

public class ThreadStopByArgs {
	/**
	 * 通过变量的形式，是线程进行停止
	 *
	 */
	public static void main(String[] args) {
		ThreadRunnerTest threadRunnerTest = new ThreadRunnerTest();
		Thread thread = new Thread(threadRunnerTest);
		thread.start();
		try {
			TimeUnit.SECONDS.sleep(2);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		System.out.println("stop");
		threadRunnerTest.changeFlag();
	}
}
class ThreadRunnerTest implements Runnable {
	private volatile boolean flag = true;
	public void run() {
		int i=0;
		while(flag) {
			//System.out.println(i++);测试多线程时，如果使用syso输出，要小心使用,因为syso中有sync
		}
	}
	public void changeFlag(){
		flag = false;
	}
}