线程安全问题
在多个线程同时访问一个相同的资源的时候会发生线程安全问题。
举个栗子：
买票问题，三个窗口进行买票。
public class ThreadSafe {
public static void main(String[] args) {
Ticket ticket = new Ticket();
Thread t1 = new Thread(ticket);
Thread t2 = new Thread(ticket);
Thread t3 = new Thread(ticket);
t1.setName("窗口一");
t2.setName("窗口二");
t3.setName("窗口三");
t1.start();
t2.start();
t3.start();
}
}
class Ticket implements Runnable{
private int ticket = 10;//有10张票
@Override
public void run() {
while (true){
if(ticket > 0){
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + "窗口：" + ticket--);
}else {
break;
}
}
}
}
运行结果：
很明显可以看出，在三个线程同时去访问Ticket类的时候，票的数量出现的重复和错误（结果为0）的情况。
为什么会出现这种情况呢？
因为线程是并发的，并发就是三个线程同时进行。比如窗口一进入run方法，然后窗口二也进入了run方法，然后两个同时操作ticket的数量，所以数量出现重复。
如何解决呢？
解决线程安全有3中方法：使用同步代码块、同步方法、Lock锁。
1、同步代码块
同步代码块就是将操作共享资源的代码放入由synchronized修饰的代码块中。
在使用同步代码块的时候需要使用一个锁将代码块锁起来，只允许一个线程进行访问。线程在进行操作数据前获得锁，操作结束后将锁释放。
任何对象都可以是锁对象，但是锁对象必须是唯一的
在这里我使用了当前这个对象来作为锁对象，因为我只声明了一个ticket对象，该对象是唯一的。
也可以在Ticket类中声明一个对象，作为锁对象。
public class ThreadSafe {
public static void main(String[] args) {
Ticket ticket = new Ticket();
Thread t1 = new Thread(ticket);
Thread t2 = new Thread(ticket);
Thread t3 = new Thread(ticket);
t1.setName("窗口一");
t2.setName("窗口二");
t3.setName("窗口三");
t1.start();
t2.start();
t3.start();
}
}
class Ticket implements Runnable{
private int ticket = 10;//有10张票
//Object obj = new Object();
@Override
public void run() {
while (true) {
synchronized (this) {//或者使用synchronized（obj）
if (ticket > 0) {
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + "卖：" + ticket-- + "号票");
} else {
break;
}
}
}
}
}
运行结果：
有结果可以看到，我们加上同步代码块之后，显示的结果就是正确的。
2、同步方法
在方法上加上synchronized关键字即可。同步方法默认的锁对象是当前对象即this对象。
class Ticket implements Runnable{
private int ticket = 10;//有10张票
@Override
public void run() {
while (true) {
sell();
}
}
private synchronized void sell(){
if (ticket > 0) {
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + "卖：" + ticket-- + "号票");
}
}
}
运行结果：
注意：在使用继承Thread类来创建线程的时候同步方法和同步代码块也会出现安全问题。因为默认使用this为锁对象，在运行的时候创建了三个ticket对象，所以三个线程使用的锁对象不一样。
这里使用同步代码块和同步方法的结果都是一样的，这里就不展示同步方法的代码了。
public class ThreadSafe {
public static void main(String[] args) {
Ticket t1 = new Ticket();
Ticket t2= new Ticket();
Ticket t3 = new Ticket();
t1.setName("窗口一");
t2.setName("窗口二");
t3.setName("窗口三");
t1.start();
t2.start();
t3.start();
}
}
class Ticket extends Thread{
private int ticket = 10;//有10张票
@Override
public void run() {
while (true) {
synchronized (this) {
if (ticket > 0) {
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + "卖：" + ticket-- + "号票");
} else {
break;
}
}
}
}
}
运行结果：
从结果可以看出来，每个窗口都卖了10张票，因为三个线程有着不同的锁。
解决办法就是使用当前类作为锁对象。
synchronized(Ticket.class){
//执行语句...
}
为什么使用Ticket.class可以呢？
因为Ticket.class返回的是一个Class类的对象。该对象时唯一的。
3、使用Lock锁
使用Lock锁来解决线程安全问题时，需要使用到Lock对象中的两个方法：
lock(） 获得锁
unlock() 释放锁
class Ticket extends Thread{
private int ticket = 10;//有10张票
private Lock lock = new ReentrantLock();
@Override
public void run() {
while (true) {
lock.lock();
try {//使用try-finally可以保证所被释放
if (ticket > 0) {
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + "卖：" + ticket-- + "号票");
} else {
break;
}
}finally {
lock.unlock();
}
}
}
}
运行结果：
Lock和synchronized的区别？
synchronized会自动释放锁，Lock需要手动启动锁和释放锁。
三种方式优先级
Lock锁 > 同步代码块 > 同步方法