synchronized的用法以及常见的使用错误

synchronized的作用是实现线程之间的同步，既能保证可见性，又能保证原子性。

用法也有很多种，如下所示



用一个线程类来演示下这三种:

指定加锁对象:

package com.bckj.Thread;

/**
* Created by Admin on 2017/6/23.
*/
public class SynchronizedTest {
static int x;
static class AddThread implements Runnable{
Object o = new Object();
@Override
public synchronized void run() {
for(int i=1;i<=1000;i++){
synchronized (o){
x++;
}
}
}
}
public static void main(String[] args) throws InterruptedException {
Runnable run = new AddThread();
Thread addThread1 = new Thread(run);
Thread addThread2 = new Thread(run);
addThread1.start();
addThread2.start();
//让主线程等待上面两个线程执行完毕
addThread1.join();
addThread2.join();
System.out.println(x);
}
}

直接作用于实例方法:

package com.bckj.Thread;

/**
* Created by Admin on 2017/6/23.
*/
public class SynchronizedTest {
static int x;
static class AddThread implements Runnable{
public synchronized void increase(){
x++;
}
@Override
public synchronized void run() {
for(int i=1;i<=1000;i++){
increase();
}
}
}
public static void main(String[] args) throws InterruptedException {
Runnable run = new AddThread();
Thread addThread1 = new Thread(run);
Thread addThread2 = new Thread(run);
addThread1.start();
addThread2.start();
//让主线程等待上面两个线程执行完毕
addThread1.join();
addThread2.join();
System.out.println(x);
}
}

直接作用于静态方法:

package com.bckj.Thread;

/**
* Created by Admin on 2017/6/23.
*/
public class SynchronizedTest {
static int x;
static class AddThread implements Runnable{
public synchronized static void increase(){
x++;
}
@Override
public synchronized void run() {
for(int i=1;i<=1000;i++){
increase();
}
}
}
public static void main(String[] args) throws InterruptedException {
Runnable run = new AddThread();
Runnable run2 = new AddThread();
Thread addThread1 = new Thread(run);
Thread addThread2 = new Thread(run2);
addThread1.start();
addThread2.start();
//让主线程等待上面两个线程执行完毕
addThread1.join();
addThread2.join();
System.out.println(x);
}
}

因为要体现静态方法，所以实例化了两个不同的AddThread对象。

新手使用synchronized的时候可能会犯下面的错误(不久前我也刚犯过)

1、

public class SynchronizedTest {
static int x;
static class AddThread implements Runnable{
public synchronized void increase(){
x++;
}
@Override
public void run() {
for(int i=1;i<=1000;i++){
increase();
}
}
}
public static void main(String[] args) throws InterruptedException {
Runnable run = new AddThread();
Runnable run2 = new AddThread();
Thread addThread1 = new Thread(run);
Thread addThread2 = new Thread(run2);
addThread1.start();
addThread2.start();
//让主线程等待上面两个线程执行完毕
addThread1.join();
addThread2.join();
System.out.println(x);
}
}

public class SynchronizedTest {
static int x;
static class AddThread implements Runnable{
Object o = new Object();
@Override
public void run() {
for(int i=1;i<=1000;i++){
synchronized (o){
x++;
}
}
}
}
public static void main(String[] args) throws InterruptedException {
Thread addThread1 = new Thread(new AddThread());
Thread addThread2 = new Thread(new AddThread());
addThread1.start();
addThread2.start();
//让主线程等待上面两个线程执行完毕
addThread1.join();
addThread2.join();
System.out.println(x);
}
}

这两种都是对线程对象中的方法或局部变量进行加锁，但是又实例化了两个不同的Runnable实例，也就是说这两个线程使用的是两把不同的锁，因此不能保证线程安全，最后x的结果也会<=2000。

2、

第二种错误就比较隐晦

public class AddThread implements Runnable{
static Integer x = 0;
@Override
public void run() {
for(int i=1;i<=1000;i++){
synchronized (x){
x++;
}
}
}
public static void main(String[] args) throws InterruptedException {
Runnable run = new AddThread();
Thread addThread1 = new Thread(run);
Thread addThread2 = new Thread(run);
addThread1.start();
addThread2.start();
//让主线程等待上面两个线程执行完毕
addThread1.join();
addThread2.join();
System.out.println(x);
}
}

这个程序看似没有错误，但是执行结果会得到比2000小的数值，主要是由于，Integer是不可变对象，对象一旦创建就不可能被修改。

通过javap反编译run方法可以看到：



可以看到i++在执行的时候变成了 i=Integer.valueOf(i.intValue()+1);

Integer.valueOf():



他会倾向于返回一个代表指定数值的Integer实例。因此，i++的本质是，创建一个新的Integer对象，并将它的引用赋值给i。

这样的话，就可以知道了，因为i这个对象可能一直在变，所以锁的对象一直在变，因此不能起到线程同步的作用，只要改成上面提到第一种用法的例子那样就可以解决。