为什么会出现线程安全问题？

线程不安全：

当多线程并发访问临界资源时，如果破坏原⼦操作，可能会造成数据不⼀致。

临界资源：共享资源（同⼀对象），⼀次仅允许⼀个线程使⽤，才可保证其正确性。

原子操作：不可分割的多步操作，被视作⼀个整体，其顺序和步骤不可打乱或缺省。

线程安全问题都是由全局变量及静态变量引起的。若每个线程中对全局变量、静态变量只有读操作，⽽⽆写操作，⼀般来说，这个全局变量是线程安全的；若有多个线程同时执⾏写操作，⼀般都需要考虑线程同步，否则的话就可能影响线程安全。

示例：

class TicketRunnable implements Runnable{private int ticket=100;//每个窗⼝卖票的操作//窗⼝ 永远开启@Overridepublic void run() {while(true){//有票可以卖//出票操作if(ticket > 0){//使⽤sleep模拟⼀下出票时间 //模拟⼀下出票的时间try {Thread.sleep(100);} catch (InterruptedException e) {e.printStackTrace();}System.out.println(Thread.currentThread().getName()+"正在卖票："+ticket--);}}}
}
public class ThreadSafe {public static void main(String[] args) throws Exception{TicketRunnable t = new TicketRunnable();Thread t1 = new Thread(t,"窗⼝1");Thread t2 = new Thread(t,"窗⼝2");Thread t3 = new Thread(t,"窗⼝3");//3个窗⼝同时卖票t1.start();t2.start();t3.start();}
}

为了保证每个线程都能正常执⾏原⼦操作,Java引⼊了线程同步机制。那么怎么去使⽤呢？有三种⽅式完成同步操作：

1. 同步代码块。

2. 同步⽅法。

3. 锁机制。

同步代码块

语法：

synchronized(临界资源对象){ //对临界资源对象加锁//代码（原⼦操作）
}

同步锁:

对象的同步锁只是⼀个概念,可以想象为在对象上标记了⼀个锁.

1. 锁对象 可以是任意类型。

2. 多个线程对象 要使⽤同⼀把锁。

注意: 在任何时候,最多允许⼀个线程拥有同步锁,谁拿到锁就进⼊代码块,其他的线程只能在外等着(BLOCKED)。

示例：

class Ticket2 implements Runnable{private int ticket=100;Object lock = new Object();//每个窗⼝卖票的操作//窗⼝ 永远开启@Overridepublic void run() {while(true){//有票可以卖synchronized(lock){//synchronized (this) {//this ---当前对象if(ticket>0){//出票操作//使⽤sleep模拟⼀下出票时间try {Thread.sleep(50);} catch (InterruptedException e) {e.printStackTrace();}System.out.println(Thread.currentThread().getName()+"正在卖票："+ticket--);}}}}
}
public class TicketDemo2 {public static void main(String[] args) {Ticket2 ticket2 = new Ticket2();Thread t1 = new Thread(ticket2,"窗⼝1");Thread t2 = new Thread(ticket2,"窗⼝2");Thread t3 = new Thread(ticket2,"窗⼝3");//3个窗⼝同时卖票t1.start();t2.start();t3.start();}
}

同步方法

同步方法 : 使⽤synchronized修饰的⽅法,就叫做同步⽅法,保证A线程执⾏该⽅法的时候,其他线程只能在⽅法外等着。

语法：

synchronized 返回值类型 ⽅法名称(形参列表){ //对当前对象（this）加锁
// 代码（原⼦操作）
}

只有拥有对象互斥锁标记的线程，才能进⼊该对象加锁的同步⽅法中。

线程退出同步⽅法时，会释放相应的互斥锁标记。

如果方式是静态，锁是类名.class。

示例：

class Ticket3 implements Runnable{private int ticket=100;//Object lock = new Object();//每个窗⼝卖票的操作//窗⼝ 永远开启@Overridepublic void run() {while(true){//有票可以卖sellTicket();if(ticket<=0){break;}}}/* 锁对象，谁调⽤这个⽅法，就是谁* 隐含锁对象，就是this* 静态⽅法，隐含锁对象就是Ticket3.class*/public synchronized void sellTicket(){if(ticket>0){//出票操作//使⽤sleep模拟⼀下出票时间try {Thread.sleep(50);} catch (InterruptedException e) {e.printStackTrace();}System.out.println(Thread.currentThread().getName()+"正在卖票："+ticket--);}}
}
public class TicketDemo3 {public static void main(String[] args) {Ticket3 ticket3 = new Ticket3();Thread t1 = new Thread(ticket3,"窗⼝1");Thread t2 = new Thread(ticket3,"窗⼝2");Thread t3 = new Thread(ticket3,"窗⼝3");//3个窗⼝同时卖票t1.start();t2.start();t3.start();}
}

synchronized注意点

同步锁是谁?

对于⾮static⽅法,同步锁就是this。

对于static方法,我们使⽤当前方法所在类的字节码对象(类名.class)。

Lock

JDK5加⼊，与synchronized⽐较，显示定义，结构更灵活。

提供更多实⽤性⽅法，功能更强⼤、性能更优越。

常用方法：

ReentrantLock：

Lock接⼝的实现类，与synchronized⼀样具有互斥锁功能。

示例：

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class MyList {//创建锁private Lock lock = new ReentrantLock();private String[] str = {"A","B","","",""};private int count = 2;public void add(String value){//当没有锁的时候，会出现覆盖的情况str[count] = value;try {Thread.sleep(100);} catch (InterruptedException e) {e.printStackTrace();}count++;System.out.println(Thread.currentThread().getName()+"添加了"+value);}public String[] getStr(){return str;}
}

测试： 

public class TestMyList {public static void main(String[] args) throws InterruptedException {MyList myList = new MyList();Thread t1 =new Thread(new Runnable() {@Overridepublic void run() {myList.add("hello");}});t1.start();Thread t2 = new Thread(new Runnable() {@Overridepublic void run() {myList.add("world");}});t2.start();t1.join();t2.join();String[] str = myList.getStr();for (String s : str) {System.out.println("s:"+s);}}
}