在Java中synchronized可用来给对象和方法或者代码块加锁，当它锁定一个方法或者一个代码块的时候，同一时刻最多只有一个线程执行这段代码。
而synchronized底层是通过使用对象的监视器锁（monitor）来确保同一时刻只有一个线程执行被修饰的方法或者代码块。
对于同步控制，我们需要明确几点：
A．无论synchronized关键字加在方法上还是对象上，它取得的锁都是对象，而不是把一段代码或函数当作锁――而且同步方法很可能还会被其他线程的对象访问。
B．每个对象只有一个锁（lock）与之相关联。
C．实现同步是要很大的系统开销作为代价的，甚至可能造成死锁，所以尽量避免无谓的同步控制。
Synchronized修饰的对象：
1.修饰一个代码块，被修饰的代码块称为同步语句块，其作用的范围是大括号{}括起来的代码，作用的对象是调用这个代码块的对象（对象锁）；
2.修饰一个方法，被修饰的方法称为同步方法，其作用的范围是整个方法，作用的对象是调用这个方法的对象（对象锁）；
3.修改一个静态的方法，其作用的范围是整个静态方法，作用的对象是这个类的所有对象（类锁）；
4.修改一个类，其作用的范围是synchronized后面括号括起来的部分，作用主的对象是这个类的所有对象（类锁）。
从上面的锁对象可以看出，Synchronized修饰的锁对象其实就2种：对象锁，类锁。
解释：
（1）对象锁：Synchronized修饰非静态方法、代码块（引入的是对象是：非静态变量、非类）；
非静态方法：
public synchronized void method(){// todo}
非静态变量：
private Object o = new Object();
public void method(){
//o 锁定的对象
synchronized(o){
// todo
}
}非类（这个可以与类对比，就可以明白）：
public void method(){
//方法里的this 指的是当前的方法，方法锁
synchronized(this){
// todo
}
}
测试：
1）当多个线程使用同一个对象sync1，即：
SyncThread sync1 = new SyncThread();
Thread thread1 = new Thread(sync1, "thread1");
Thread thread2 = new Thread(sync1, "thread2");
thread1.start();
thread2.start();因为线程thread1与thread2引入同一个对象sync1，属于同一个锁对象，所以线程执行是按照先执行thread1后释放锁，thread2才能获取锁并执行其方法。
2）当多个线程使用不同对象sync1与sync2，即：
SyncThread sync1 = new SyncThread();
SyncThread sync2 = new SyncThread();
Thread thread1 = new Thread(sync1, "thread1");
Thread thread2 = new Thread(sync2, "thread2");
thread1.start();
thread2.start();因为线程thread1与thread2引入不同对象sync1与sync2，属于不同锁对象，所以线程thread1与thread2并行执行方法。
（2）类锁：Synchronized修饰静态方法、代码块（引入的是对象是：静态变量、类）；
静态方法：
public synchronized static void method(){// todo}静态变量：
private static Object o = new Object();
public void method(){
//o 锁定的对象
synchronized(o){
// todo
}
}类（与非类对比，就可以明白）：
class SyncThread implements Runnable{
public void method(){
synchronized(SyncThread.class){
// todo 同步代码块
}
}
public void run(){
method();
}
}
测试：
1）当多个线程使用同一个对象,还是不同对象，即：
Thread thread1 = new Thread(对象1, "thread1");
Thread thread2 = new Thread(对象2, "thread2");
thread1.start();
thread2.start();线程thread1与thread2肯定是按照先后顺序执行，即：先执行thread1后，才能执行thread2。
总结：
（1）如果synchronized引入的锁对象是类锁（该类所有的对象同一把锁），那么多个线程访问该锁锁定的功能时，肯定是有先后顺序的，而不能同时执行。
（2）如果synchronized引入的锁对象是方法锁，那么多个线程访问该锁锁定的功能时，要区分是是不是同一个锁对象，是同一个锁对象，功能与类锁类似；否则，多个线程可以同时执行该锁锁定的功能。
具体功能详解与代码示例：
1.1修饰代码块
1、synchronized修饰代码块：
说明：一个线程访问一个对象中的synchronized(this)同步代码块时，其他试图访问该对象的线程将被阻塞。
例子：
public class SyncThread implements Runnable {
private static int count;
public SyncThread(){
count = 0;
}
@Override
public void run() {
synchronized (this) { //锁对象是该方法，即方法锁
for (int i = 0; i < 5; i++) {
try {
System.out.println("当前线程名称" + Thread.currentThread().getName() + ":" + (count++));
Thread.sleep(100);
} catch (Exception e) {
e.printStackTrace();
}
}
}
}
public static int getCount() {
return count;
}
}测试代码：
public class SyncThreadTest {
public static void main(String[] args) {
SyncThread sync = new SyncThread();
Thread thread1 = new Thread(sync, "thread1");
Thread thread2 = new Thread(sync, "thread2");
thread1.start();
thread2.start();
}
}
测试结果：
当前线程名称thread1:0
当前线程名称thread1:1
当前线程名称thread1:2
当前线程名称thread1:3
当前线程名称thread1:4
当前线程名称thread2:5
当前线程名称thread2:6
当前线程名称thread2:7
当前线程名称thread2:8
当前线程名称thread2:9结果分析：
当并发的2个线程（thread1，thread2）访问同一个对象（sync）中的synchronized代码块时，同一个时刻只能被一个线程访问；而另一个线程只能被堵塞，且必须要等待当前线程访问完，并获取已释放对象锁，才能访问该同步的代码块。线程Thread1和thread2是互斥的，因为在执行synchronized代码块时会锁定当前的对象（同一个对象sync），只有执行完该代码块才能释放该对象锁，下一个线程才能执行并锁定该对象。
那怎么才能引入不同的对象？
修改一下测试代码：
public class SyncThreadTest {
public static void main(String[] args) {
SyncThread sync1 = new SyncThread();
SyncThread sync2 = new SyncThread();
Thread thread1 = new Thread(sync1, "thread1");
Thread thread2 = new Thread(sync2, "thread2");
thread1.start();
thread2.start();
}
}
测试结果：
当前线程名称thread1:0
当前线程名称thread2:1
当前线程名称thread2:3
当前线程名称thread1:2
当前线程名称thread1:4
当前线程名称thread2:5
当前线程名称thread2:6
当前线程名称thread1:7
当前线程名称thread2:8
当前线程名称thread1:9结果分析：
不是说一个线程执行synchronized代码块时其它的线程受阻塞吗？为什么上面的例子中thread1和thread2同时在执行？
原因：这时创建了2个SyncThread对象分别为sync1和sync2，线程thread1执行的是对象sync1中的run；而线程thread2执行的是对象sync2中的run。由于2个不同的对象sync1和sync2，synchronized会为它们分别分配2个对象锁，而这2把锁是互不干扰，不形成互斥关系，所以会并行执行。
2、代码块中引入不同的对象，即指定对象上加锁：（成员变量，类变量-静态变量）
public class SynchronizedObjectDemo {
//静态的全局变量，类变量(可以是自定义对象)
private static Object staticObject = new Object();
//非静态变量，成员变量(可以是自定义对象)
private Object o = new Object();
/**
* 功能描述: <br>
* 类变量的方法上锁
*/
public void printStaticObject(){
synchronized (staticObject) { //staticObject是静态变量，即类变量上锁
try {
//调用线程休眠5秒,锁竞争效果更加明显
Thread.sleep(5000);
} catch (InterruptedException e) {
e.printStackTrace();
}finally{
//输出表示被调用
System.out.println(System.currentTimeMillis()+" printByStaticObj is called");
}
}
}
/**
* 功能描述: <br>
* 在成员变量上锁的方法
*/
public void printObj(){
synchronized (o) { //o是成员变量
try {
//调用线程休眠5秒,锁竞争效果更加明显
Thread.sleep(5000);
} catch (InterruptedException e) {
e.printStackTrace();
}finally{
//输出表示被调用
System.out.println(System.currentTimeMillis()+" printByObj is called");
}
}
}
public static void main(String[] args) {
//定义一个线程组
ThreadGroup tgroups = new ThreadGroup(Thread.currentThread().getThreadGroup(), "SynchronizedObjectDemo");
//循环，每次启动一个线程
for (int i = 0; i < 5 ; i++) {
//每一个线程，重新构造对象
final SynchronizedObjectDemo syncObj = new SynchronizedObjectDemo();
//构造新线程的时候把它加入到定义的线程组
Thread obj = new Thread(tgroups, new Runnable() {
@Override
public void run() {
syncObj.printObj();
}
});
obj.start();
}
while (true) {//直到定义的线程组中的线程都终止才执行后续步骤
if(tgroups.activeCount() == 0){
for (int i = 0; i < 5; i++) {
final SynchronizedObjectDemo syncObj = new SynchronizedObjectDemo();
//构造新线程的时候把它加入到定义的线程组
Thread obj = new Thread(tgroups, new Runnable() {
@Override
public void run() {
syncObj.printStaticObject();
}
});
obj.start();
}
break;
}
}
}
}分析：
从这个输出结果可以看出，其实对于一个类变量加锁就类似给静态方法加锁，需要注意的一点是静态方法锁定的是Class对象，而由于类变量全局只有一个，所以行为是类似静态方法，但是锁定的不是同一个对象。
同样，而对于一个成员变量加锁就类似给非静态方法加锁。
注意：如果把第一次for循环中的SynchronizedObjectDemo对象的构造放到第一次for循环之前的话，输出的结果就会类似第二次for循环了，因为此时锁的是同一个对象。
除此之外还可以有其他方式指定锁对象：
方式一（作为方法参数）：
public void method3(SomeObject obj){
//obj 锁定的对象
synchronized(obj){
// todo
}
}方式二（当没有明确的对象作为锁，只是想让一段代码同步时，可以创建一个特殊的对象来充当锁，如上面的Object对象，但是并不是最经济的方式）：
class Test implements Runnable{
private byte[] lock = new byte[0]; // 特殊的instance变量
public void method(){
synchronized(lock) {
// todo 同步代码块
}
}
public void run() {
}
}说明：零长度的byte数组对象创建起来将比任何对象都经济――查看编译后的字节码：生成零长度的byte[]对象只需3条操作码，而Object lock = new Object()则需要7行操作码。
3、当一个线程访问对象的一个synchronized(this)同步代码块时，另一个线程仍然可以访问该对象中的非synchronized(this)同步代码块。
代码示例：
public class Counts implements Runnable {
private int count;
public Counts(){
count = 0;
}
//synchronized方法
public void countAdd(){
synchronized (this) {
for (int i = 0; i < 5; i++) {
try {
System.out.println("当前线程名称" + Thread.currentThread().getName() + ":" + (count++));
Thread.sleep(100);
} catch (Exception e) {
e.printStackTrace();
}
}
}
}
//非synchronized方法,未对count进行写操作，所以可以不用synchronized
public void countRead(){
for (int i = 0; i < 5; i++) {
try {
System.out.println("当前线程名称" + Thread.currentThread().getName() + ":" + count);
Thread.sleep(100);
} catch (Exception e) {
e.printStackTrace();
}
}
}
@Override
public void run() {
String threadName = Thread.currentThread().getName();
if (threadName.equals("A")) {
countAdd();
} else if (threadName.equals("B")) {
countRead();
}
}
}
测试代码：
public class CountsTest {
public static void main(String[] args) {
Counts counter = new Counts();
Thread thread1 = new Thread(counter, "A");
Thread thread2 = new Thread(counter, "B");
thread1.start();
thread2.start();
}
}测试结果：
当前线程名称A:0
当前线程名称B:1
当前线程名称A:1
当前线程名称B:2
当前线程名称A:2
当前线程名称B:3
当前线程名称A:3
当前线程名称B:3
当前线程名称B:4
当前线程名称A:4结果分析：
上面代码中countAdd是一个synchronized的，countRead是非synchronized的。从上面的结果中可以看出，在线程A访问synchronized的countAdd方法过程中，线程B可以同时访问非synchronized的countRead方法。也就是说：一个线程访问一个对象的synchronized代码块时，别的线程可以访问该对象的非synchronized代码块，而不受阻塞。
1.2修饰方法
1.修饰非静态方法
说明：Synchronized修饰一个方法很简单，就是在方法的前面加synchronized，
public synchronized void method(){//todo};synchronized修饰方法和修饰一个代码块类似，只是作用范围不一样，修饰代码块是大括号括起来的范围，而修饰方法范围是整个方法。如将【Demo1】中的run方法改成如下的方式，实现的效果一样。
Synchronized作用于整个方法的写法。
写法一：
public synchronized void method(){
// todo
}
写法二：
public void method(){
synchronized(this) {
// todo
}
}
写法一修饰的是一个方法，写法二修饰的是一个代码块，但写法一与写法二是等价的，都是锁定了整个方法时的内容。
注意点：
（1）synchronized关键字不能继承。
虽然可以使用synchronized来定义方法，但synchronized并不属于方法定义的一部分。因此，synchronized关键字不能被继承。
如果在父类中的某个方法使用了synchronized关键字，而在子类中覆盖了这个方法，在子类中的这个方法默认情况下并不是同步的，而必须显式地在子类的这个方法中加上synchronized关键字才可以。
当然，还可以在子类方法中调用父类中相应的方法，这样虽然子类中的方法不是同步的，但子类调用了父类的同步方法，因此，子类的方法也就相当于同步了。
示例代码如下：
1）在子类方法中加上synchronized关键字
父类：
class Parent {
public synchronized void method() { }
}
子类：
class Child extends Parent {
public synchronized void method() { }
}2）在子类方法中调用父类的同步方法
父类：
class Parent {
public synchronized void method() { }
}
子类：
class Child extends Parent {
public void method() { super.method(); }
}（2）在定义接口方法时不能使用synchronized关键字。
（3）构造方法不能使用synchronized关键字，但可以使用synchronized代码块来进行同步。
2．修饰静态方法
代码示例：
public class StaticMethod implements Runnable{
private static int count;
public StaticMethod(){
count = 0;
}
//静态方法
public synchronized static void getCounts(){ //属于类级别的锁，对于不同对象不可同时进入同一个类
for (int i = 0; i < 5; i++) {
try {
System.out.println("当前线程名称" + Thread.currentThread().getName() + ":" + (count++));
Thread.sleep(100);
} catch (Exception e) {
e.printStackTrace();
}
}
}
@Override
public synchronized void run() { //属于方法级别的锁，对于不同对象可同时进入
getCounts();
}
}
测试代码：
public class StaticMethodTest {
public static void main(String[] args) {
StaticMethod sync1 = new StaticMethod();
StaticMethod sync2 = new StaticMethod();
Thread thread1 = new Thread(sync1, "thread1");
Thread thread2 = new Thread(sync2, "thread2");
thread1.start();
thread2.start();
}
}
结果分析：
sync1和sync2是StaticMethod的两个对象，但在thread1和thread2并发执行时却保持了线程同步。这是因为run中调用了静态方法getCounts，而静态方法是属于类的，所以sync1和sync2相当于用了同一把锁。这与非静态方法是不同的。
1.3修饰一个类
说明：对于类锁，有几种方式：（1）synchronized修饰静态方法；（2）synchronized修饰静态变量；（3）synchronized代码块中直接引入类名称。前2种方式，前面已经做了详细的解释，这里主要解释第三种。
代码示例：
class ClassName {
public void method() {
synchronized(ClassName.class) {
// todo
}
}
}
synchronized作用于一个类ClassName时，是给这个类ClassName加锁，ClassName的所有对象用的是同一把锁。
参考资料：
