出现的原因
当多条语句在操作同一个线程共享数据时，一个线程对多条语句只执行了一部分，还没有执行完，另一个线程参与进来执行。导致共享数据的错误。
示例
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
| class Window implements Runnable{
private int ticket = 10;
@Override
public void run() {
while (true){
if (ticket > 0){
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+"卖票，票号："+ticket);
ticket--;
}else {
break;
}
}
}
}
public class TicketDemo {
public static void main(String[] args) {
Window w = new Window();
Thread t1 = new Thread(w);
Thread t2 = new Thread(w);
Thread t3 = new Thread(w);
t1.setName("窗口1");
t2.setName("窗口2");
t3.setName("窗口3");
t1.start();
t2.start();
t3.start();
}
}
|
在这个示例中，三个窗口代表三个线程同时出售10张票，运行结果中却出现了错票，有0和-1的票号。这就是一个线程在操作共享数据的过程中，其他线程也参与了运算，导致线程安全问题的产生。
解决办法
对多条操作共享数据的语句，只能让一个线程都执行完，在执行过程中，其他线程不可以参与执行。
Java对于多线程的安全问题提供了专业的解决方式：同步机制
同步锁机制就是是当资源被一个任务使用时，在其上加锁。第一个访问某项资源的任务必须锁定这项资源，使其他任务在其被解锁之前，无法访问它，而在其被解锁之时，另一个任务就可以锁定并使用它。
1. 同步代码块
示例
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
| class Window implements Runnable{
private int ticket = 10;
@Override
public void run() {
while (true){
synchronized(this){
if (ticket > 0){
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+"卖票，票号："+ticket);
ticket--;
}else {
break;
}
}
}
}
}
public class TicketDemo {
public static void main(String[] args) {
Window w = new Window();
Thread t1 = new Thread(w);
Thread t2 = new Thread(w);
Thread t3 = new Thread(w);
t1.setName("窗口1");
t2.setName("窗口2");
t3.setName("窗口3");
t1.start();
t2.start();
t3.start();
}
}
|
同步代码块中的锁可以自己指定，很多时候指定为this或类名.class。任何对象都可以作为同步锁，所有对象都自动含有单一的锁（监视器）。
例如使用实现Runnable接口的方式实现多线程，由于多个线程共用一个对象，此时同步锁可以是任意对象。若是使用继承Thread的方式实现多线程，由于多个线程间不是同一个对象，此时只能使用类名.class或者静态对象。总而言之必须确保使用同一个资源的多个线程共用一把锁，这个非常重要，否则就无法保证共享资源的安全。
2. 同步方法
1
2
3
| public synchronized void show (String name){
…
}
|
示例
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
| class Window extends Thread{
private static int ticket = 10;
private static Object obj = new Object();
@Override
public void run() {
while (ticket != 0){
sell();
}
}
private static synchronized void sell(){
if (ticket > 0){
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+"卖票，票号："+ticket);
ticket--;
}
}
}
public class TicketDemo {
public static void main(String[] args) {
Window w1 = new Window();
Window w2 = new Window();
Window w3 = new Window();
w1.setName("窗口1");
w2.setName("窗口2");
w3.setName("窗口3");
w1.start();
w2.start();
w3.start();
}
}
|
- 同步方法的锁：静态方法（类名.class）、非静态方法（this）
- 一个线程类中的所有静态方法共用同一把锁（类名.class），所有非静态方法共用同一把锁（this）
3. Lock（锁）
从JDK 5.0开始，Java提供了更强大的线程同步机制——通过显式定义同步锁对象来实现同步。同步锁使用Lock对象充当。
java.util.concurrent.locks.Lock接口是控制多个线程对共享资源进行访问的 工具。锁提供了对共享资源的独占访问，每次只能有一个线程对Lock对象 加锁，线程开始访问共享资源之前应先获得Lock对象。
ReentrantLock类实现了 Lock ，它拥有与synchronized 相同的并发性和内存语义，在实现线程安全的控制中，比较常用的是ReentrantLock，可以显式加锁、释放锁。
1
2
3
4
5
6
7
8
9
10
11
12
| class A{
private final ReentrantLock lock = new ReenTrantLock();
public void m(){
lock.lock();
try{
}
finally{
lock.unlock();
}
}
}
|
示例
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
| import java.util.concurrent.locks.ReentrantLock;
class Window implements Runnable{
private int ticket = 10;
private ReentrantLock lock = new ReentrantLock();
@Override
public void run() {
while (true){
try {
lock.lock();
if(ticket > 0){
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+"卖票，票号："+ticket);
ticket--;
}else {
break;
}
} finally {
lock.unlock();
}
}
}
}
public class LockTest {
public static void main(String[] args) {
Window w = new Window();
Thread t1 = new Thread(w);
Thread t2 = new Thread(w);
Thread t3 = new Thread(w);
t1.setName("窗口1");
t2.setName("窗口2");
t3.setName("窗口3");
t1.start();
t2.start();
t3.start();
}
}
|
Lock是显式锁（手动开启和关闭锁，别忘记关闭锁），synchronized是隐式锁，出了作用域自动释放。使用Lock锁，JVM将花费较少的时间来调度线程，性能更好。并且具有更好的扩展性（提供更多的子类）
