synchronized简介

synchronized方法控制对类对象方法的访问，每个类对象都对应一把锁，每个synchronized 方法都必须获得该方法所属对象的锁方能执行，否则所属线程阻塞，方法一旦执行，就独占该对象锁，直到从该方法返回时才将锁释放，此后被阻塞的线程方能获得该锁，重新进入可执行状态。这种机制确保了同一时刻对于每一个对象实例，其所有声明为 synchronized 的实例函数中至多只有一个处于可执行状态，从而有效避免了类成员变量的访问冲突。注意，其它非synchronized的函数仍可被其它线程同时访问。

synchronized基本用法

• 修饰普通方法

public synchronized void inc(int i)   {
    i++;
}

• 修饰静态方法

public static synchronized void inc(int i)   {
    i++;
}

• 修饰代码块

public void inc(int i) {
    synchronized(this) {
        i++;
    }
}

哪个对象才是锁？？？

首先看两个例子：

class Foo extends Thread {
    private int val;

    public Foo(int v) {
        val = v;
    }

    public synchronized void printVal(int v) {
        while (true) {
            System.out.println(v);
        }
    }

    public void run() {
        printVal(val);
    }
}

public class SyncTest {
    public static void main(String args[]) {
        Foo f1 = new Foo(1);
        f1.start();
        Foo f2 = new Foo(3);
        f2.start();
    }
}
//运行结果：
1
1
3
3
.....//1和3循环出现
修改为：
class Foo extends Thread {
    private int val;

    public Foo(int v) {
        val = v;
    }

  
    public void printVal(int v) {
        synchronized(Foo.class) {
            while(true)
                System.out.println(v);
        }
    }

    public void run() {
        printVal(val);
    }
}
//运行结果：
1
1
1
......//1循环出现，没有出现3

总结：同一时刻对于每一个对象实例，其所有声明为 synchronized 的实例函数中至多只有一个处于可执行状态。第一个例子有两个实例对象，所以他们都可以访问printVal方法；第二个例子只有一个类对象，所以只有一个实例可以访问printVal方法。

synchronized特点

• 可重入锁

这个特性主要是针对当前线程而言的，可重入即是自己可以再次获得自己的内部锁，在尝试获取对象锁时，如果当前线程已经拥有了此对象的锁，则把锁的计数器加一，在释放锁时则对应地减一，当锁计数器为0时表示锁完全被释放，此时其他线程可对其加锁。可重入可以避免死锁（线程自己锁死自己）。

• 非公平锁

非公平主要表现在获取锁的行为上，并非是按照申请锁的时间前后给等待线程分配锁的，每当锁被释放后，任何一个线程都有机会竞争到锁，这样做的目的是为了提高执行性能，当然也会产生线程饥饿现象。

• 不可中断性

在所有等待的线程中，你们唯一能做的就是等，而实际情况可能是有些任务等了足够久了，我要取消此任务去干别的事情，此时synchronized是无法帮你实现的，它把所有实现机制都交给了JVM，提供了方便的同时也体现出了自己的局限性。

• 只能绑定一个条件

锁对象的wait()和notify()或notifyAll()方法可以实现一个隐含的条件，如果要和多于一个条件关联时，只能再加一个额外的锁。

• 主动释放锁

线程进入同步代码块或方法的时候会自动获得该锁，在退出同步代码块或方法时会释放该锁。