多个线程同时运行一段代码，每次运行结果和单线程运行结果一样，且其他变量值也和预期一样，就称为线程安全。
我们通过模拟电影院卖票来感受下线程的安全问题：
票及卖票过程：Runnable接口的子类；卖票窗口：线程对象。 public class Ticket implements Runnable { private int ticket = 100; // 执行卖票操作 @Override public void run() { // 每个窗口卖票的操作 // 窗口永远开启 while(true) { if(ticket>0){// 有票可以卖 // 出票操作 // 使用sleep模拟一下出票时间 try{ Thread.sleep(100); } catch (InterruptedException e) { e.printStackTrace(); } // 获取当前线程对象的名字 String name = Thread.currentThread().getName(); System.out.println(name + "正在卖：" + ticket--); } } } } public class Demo { public static void main(String[] args) { // 创建线程任务对象 Ticket ticket = new Ticket(); // 创建三个窗口对象 Thread t1 = new Thread(ticket, "窗口1"); Thread t2 = new Thread(ticket, "窗口2"); Thread t3 = new Thread(ticket, "窗口3"); // 同时卖票 t1.start(); t2.start(); t3.start(); } } // 运行结果 ... 窗口1正在卖：3 窗口2正在卖：3 窗口3正在卖：2 窗口3正在卖：1 窗口1正在卖：0 窗口2正在卖：-1可以发现程序存在以下两个问题：
相同的票数比如第3张票被卖了两次；不存在的票，比如0票和-1票，不应当出现。也就是说，这几个窗口（线程）票数不同步了，这就是线程不安全。
当我们使用多个线程访问同一资源的时候，且多个线程对资源有写的操作，就容易出现线程安全问题。
要解决上述多线程并发访问同一个资源的安全性问题：即重复票和不存在票的问题，Java中提供了同步机制（synchronized）来解决。
根据案例简述：
窗口1线程进入操作的时候，窗口2和窗口3线程只能在外等着，窗口1操作结束，窗口1、窗口2、窗口3才有机会进入代码去执行。也就是说在某个线程修改共享资源的时候，其他线程不能修改该资源，等待修改完毕同步之后，才能去抢夺CPU资源，完成对应的操作，保证了数据的同步性，解决了线程不安全现象。
同步机制的3种实现方式：
同步代码块；同步方法；锁机制。同步代码块：synchronized关键字，可以用于方法中的某个区块中，表示只对这个区块的资源实行互斥访问。
格式：
synchronized(同步锁) { 需要同步操作的代码 }对象的同步锁只是一个概念，可以想象在对象上标记了一把锁：
锁对象可以是任意类型；多个线程对象要使用同一把锁。在任何时候，最多允许一个线程拥有同步锁，谁拿到锁谁就进入代码块，其他的线程只能在外等着（Blocked）。
使用同步代码块代码如下：
public class Ticket implements Runnable { private int ticket = 100; Object lock = new Object(); // 执行卖票操作 @Override public void run() { // 每个窗口卖票的操作 // 窗口永远开启 while(true) { synchronized (lock) { if (ticket > 0) {// 有票可以卖 // 出票操作 // 使用sleep模拟一下出票时间 try { Thread.sleep(100); } catch (InterruptedException e) { e.printStackTrace(); } // 获取当前线程对象的名字 String name = Thread.currentThread().getName(); System.out.println(name + "正在卖：" + ticket--); } } } } }使用了同步代码块后，上述的线程安全问题就解决了。
同步方法：使用synchronized修饰的方法就叫作同步方法，保证一个线程执行该方法的时候，其他线程只能在方法外等着。
格式：
public sychronized void method() { 可能会产生线程安全问题的代码 }同步锁是谁?
对于非static方法,同步锁就是this；对于static方法,我们使用当前方法所在类的字节码对象(类名.class)。使用同步锁代码如下：
public class Ticket implements Runnable { private int ticket = 100; // 执行卖票操作 @Override public void run() { // 每个窗口卖票的操作 // 窗口永远开启 while(true) { sellTicket(); } } // 谁调用这个方法谁就是锁对象，隐含锁对象就是this public synchronized void sellTicket(){ if (ticket > 0) {// 有票可以卖 // 出票操作 // 使用sleep模拟一下出票时间 try { Thread.sleep(100); } catch (InterruptedException e) { e.printStackTrace(); } // 获取当前线程对象的名字 String name = Thread.currentThread().getName(); System.out.println(name + "正在卖：" + ticket--); } } }java.util.concurrent.locks.Lock机制提供了比synchronized代码块和sychronized方法更广泛的同步操作，同步代码块/同步方法具有的功能Lock都有，除此之外更强大，更体现面向对象。
Lock锁也称同步锁，将加锁和释放锁方法化：
public void lock()：加同步锁；public void unlock()：释放同步锁。代码示例如下：
public class Ticket implements Runnable { private int ticket = 100; Lock lock = new ReentrantLock(); // 执行卖票操作 @Override public void run() { // 每个窗口卖票的操作 // 窗口永远开启 while(true) { lock.lock(); if(ticket>0){// 有票可以卖 // 出票操作 // 使用sleep模拟一下出票时间 try{ Thread.sleep(100); } catch (InterruptedException e) { e.printStackTrace(); } // 获取当前线程对象的名字 String name = Thread.currentThread().getName(); System.out.println(name + "正在卖：" + ticket--); } lock.unlock(); } } }