程序的同步

1. 线程的同步：（synchronized）
   当我们使用多线程访问同一资源的时候，且这多个线程中对资源有的写的操作，就容器出现线程安全问题。
   要解决多线程并发访问一个资源的安全问题，java中提供了同步机制(synchronized)来解决。
   原理：
   窗口1线程进入操作的时候，窗口2和窗口3线程只能在外面等着，当窗口1线程操作结束，窗口1和窗口2和窗口3才有机会进入代码中去执行。也就是说某个线程修改共享资源的时候，其他线程不能修改共享资源，等待修改完毕同步后，才能去抢夺cpu的使用资源，完成对应的操作，保证了数据的同步性。解决了线程不安全的问题。

2. 有三种方式实现同步机制：
   1. 同步代码块
   2. 同步方法
   3. 锁机制
   2.1. 同步代码块
   同步代码块:synchronized关键字可以用于方法中的某个代码块中，表示只对这个代码块的资源实行互斥访问

		synchronized(同步锁){
			// 需要同步的操作的代码
		}

2.1.1 同步锁
	同步锁是一个对象，是一个抽象的概念，可以想象成在对象上标记了一个锁
		1. 锁对象可以是任意类型的。Object
		2. 多个线程对象，要使用同一把锁
	注意：在任何时候，最多允许一个线程拥有同步锁，谁拿到同步锁谁就拥有资格进入代码块中，其他的线程只能在外面等待着。（Blocked阻塞状态）

同步原理图解：
2.2. 同步方法
2.2.1 同步方法：使用synchronized修饰的方法，就叫做同步方法，保证A线程执行该方法的时候，其他线程只能在方法的外面等待，排队
格式：

public void synchronized void method(){
	// 可能会产生线性安全问题的代码
}

备注：
同步锁是谁？
对于非static 方法，同步锁就是this
对于static 方法，我们使用当前方法所在类的字节码对象(类名.class)

同步方法代码示例如下：

package com.zhiyou100.thread.demo01;

// 实现卖票案例
/*
 * 解决线程安全问题的第二种方案：使用同步方法
 * 	使用步骤：
 * 		1.把访问共享数据的代码抽取出来，放到一个方法中
 *      2.在方法上面添加synchronized修饰符
 *      
 *  格式：
 *  	定义方法的格式
 *  修饰符 synchronized 返回值类型  方法名(参数列表) {
 *  	// 可能会产生线程安全问题的代码(访问共享数据的代码)
 *  }
 * 
 */
public class RunnableImpl implements Runnable {
	// 定义一个多线程共享的资源 票
	private static int ticket = 100;

	// 设置线程的任务：卖票 此时窗口--->线程
	@Override
	public void run() {
		System.out.println(RunnableImpl.class);
		// com.zhiyou100.thread.demo01.RunnableImpl@15db9742
		System.out.println("this ---->" + this);
		// 先判断票是否存在
		System.out.println();
		while (true) {
			saleTicket();
		}
	}

	/*
	 * 静态的同步方法 锁对象 不能是this this是创建对象之后产生的，静态方法优先于对象的创建
	 * 静态同步方法中的锁对象是本类的class属性--->class文件对象(反射)
	 */

	public static synchronized void saleTicket() {

		synchronized (RunnableImpl.class) {
			if (ticket > 0) {
				// 提高卖票的体验感 ，让程序睡眠下
				try {
					Thread.sleep(10);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
				// 票存在，卖出第ticket张票
				System.out.println(Thread.currentThread().getName() + "---->正在售卖第" + ticket + "张票");
				ticket--;
			}
		}
	}

	/*
	 * 定义一个同步方法 同步方法也会把方法内部的代码锁住 只让一个线程访问 同步方法中的锁对象是谁？ 就是实现类对象 new RunnableImpl()
	 * 也就是this
	 */
	/*public synchronized void saleTicket() {
		 synchronized (this) { 
		if (ticket > 0) {
			// 提高卖票的体验感 ，让程序睡眠下
			try {
				Thread.sleep(10);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			// 票存在，卖出第ticket张票
			System.out.println(Thread.currentThread().getName() + "---->正在售卖第" + ticket + "张票");
			ticket--;
		}
		 } 
	}*/
}

2.3 Lock锁
java.util.concurrent.locks.Lock机制提供了比synchronized代码块和synchronized同步方法更加广泛的锁操作，
同步代码块/同步方法具有的功能，Lock都有，除此之外更强大，更能体现出面向对象特征。
Lock锁也称为同步锁，定义了加锁与解锁的动作，方法如下：
public void lock(); 加同步锁
public void unlock(); 释放同步锁

备注：
锁是控制多个线程对共享资源进行访问的工具。通常，锁提供了对共享资源的独占访问。一次只能有一个线程获得锁，对共享资源的所有访问都需要首先获得锁
示例代码如下：

public class RunnableImpl implements Runnable {
	// 定义一个多线程共享的资源 票
	private int ticket = 100;	
	// 1. 在成员的位置创建一个ReentrankLock对象
	Lock Lock = new ReentrantLock();
	// 设置线程的任务：卖票  此时窗口--->线程
	@Override
	public void run() {
		// 先判断票是否存在
		while(true){
			// 2. 在可能会引发线程安全问题的代码前调用Lock接口中的lock方法获取锁
			Lock.lock();
			if (ticket > 0) {
				// 提高卖票的体验感 ，让程序睡眠下
				try {
					Thread.sleep(10);
					// 票存在，卖出第ticket张票
					System.out.println(Thread.currentThread().getName() + "---->正在售卖第" + ticket + "张票");
					ticket--;
				} catch (InterruptedException e) {
					e.printStackTrace();
				} finally {
					// 无论程序出现异常，此时都会把锁释放掉
					// 在finally语句块中一般用于资源的释放，关闭IO流，释放lock锁，关闭数据库连接等等
					// 3.在可能会引发线程安全问题的代码后调用Lock接口中的unlock释放锁。
					Lock.unlock();
				}
			}
		}
	}
}