首先先看看下面的代码：
public class checkSynchronized extends Thread{
static volatile int i = 0;
public static void increase() {
i++;
}
@Override
public void run() {
for (int j = 0; j < 1000000; j++) {
increase();
}
}
public static void main(String args[]) throws InterruptedException {
Thread t1 = new checkSynchronized();
Thread t2 = new checkSynchronized();
t1.start();
t2.start();
t1.join();
t2.join();
System.out.println("i : " + i);
}
}
执行上述代码，你会发现大部分情况下i的最终值都会小于2000000的
为什么加了volatile关键词的变量依旧会出现线程安全问题呢？
这是因为volatile只保证可见性，不保证原子性
volatile.jpg
图为两条线程同时对i进行写入时，一个线程的结果会覆盖另一线程的结果，造成线程安全问题。
解决此问题就应该在线程甲进行写入值时，线程乙不仅不能写入、而且还不能读取值，如果读取值的话就会读取到一个旧值，依旧会造成线程安全问题。那该如何实现呢？
在这里就要引出今天的主角了："Synchronized"
关键字synchronized的作用就是实现线程间的同步问题，它能将同步区的代码进行加锁，一次只能允许一条线程进入同步区，以保证同步区中的线程安全问题。
下面就来测试下该关键字的作用：
public class checkSynchronized extends Thread{
Object lock;
checkSynchronized(Object lock) {
this.lock = lock;
}
static volatile int i = 0;
public static void increase() {
i++;
}
@Override
public void run() {
synchronized (lock) {
for (int j = 0; j < 1000000; j++) {
increase();
}
}
}
public static void main(String args[]) throws InterruptedException {
Object lock = new Object();
Thread t1 = new checkSynchronized(lock);
Thread t2 = new checkSynchronized(lock);
t1.start();
t2.start();
t1.join();
t2.join();
System.out.println("i : " + i);
}
}
大家可以看到在run()方法里加了synchronized，并且指定了锁对象。
运行结果：i : 2000000
在这里简单地整理下synchronized的多种用法：
- 指定锁对象，进入前须先获得给定对象的锁（如上述代码所述）
- 加在实例方法，进入前须获得当前实例的锁
- 加在静态方法，进入前须获得当前类的锁
在这里给出一段错误代码，大家需要明白：
public static void main(String args[]) throws InterruptedException {
Object lock1 = new Object(); //生成第一个锁
Object lock2 = new Object(); //生成第二个锁
Thread t1 = new checkSynchronized(lock1);
Thread t2 = new checkSynchronized(lock2);
t1.start();
t2.start();
t1.join();
t2.join();
System.out.println("i : " + i);
}
这段代码表示出各自线程最终使用了各自的锁，线程安全是无法保证的。
对于作用在实例方法上的也要注意，因为其可能会发生和上述相同原因的线程安全错误。
public class checkSynchronized implements Runnable{
static volatile int i = 0;
public synchronized void increase() {
i++;
}
@Override
public void run() {
for (int j = 0; j < 1000000; j++) {
increase();
}
}
public static void main(String args[]) throws InterruptedException {
checkSynchronized onlyOne = new checkSynchronized();
Thread t1 = new Thread(onlyOne);
Thread t2 = new Thread(onlyOne);
t1.start();
t2.start();
t1.join();
t2.join();
System.out.println("i : " + i);
}
}
上述代码的synchronized作用在实例方法上，锁为当前实例。所以在main方法中只实例了一个checkSynchronized实例，因为锁只需要一个、多了就会出现安全问题。
如果实例了两个对象,则会出现安全问题（锁多了和不加锁就没啥区别了），如下述代码：
public static void main(String args[]) throws InterruptedException {
checkSynchronized onlyOne = new checkSynchronized();
checkSynchronized wrong = new checkSynchronized();
Thread t1 = new Thread(onlyOne);
Thread t2 = new Thread(wrong);
t1.start();
t2.start();
t1.join();
t2.join();
System.out.println("i : " + i);
}
解决的办法非常容易，只需在加了锁的实例方法加上"static"关键字就行。
public static synchronized void increase()
这样锁就作用在类方法上了。当线程要执行该同步方法时是请求当前类的锁并非实例的锁，所以再多的实例线程之间依旧能正确同步。
synchronized不仅用于线程同步、确保线程安全问题外，还能保证线程之间的可见性和有序性问题。相当于是volatile的升级版。但被synchronized限制的多线程之间是串行执行的，所带来的性能消耗是很大的。
