synchronize关键字

1.synchronized关键字分别加在两个方法上：

import java.util.concurrent.TimeUnit;

public class TT extends Thread {
    int b=100;

    public synchronized void m1(){
        b=1000;
        System.out.println("m1给b赋值");
        try{
            Thread.sleep(2000);
            System.out.println("m1睡醒");
        }catch(Exception e){
            e.printStackTrace();
        }
        System.out.println("m1中b="+b);
    }

    public synchronized void m2(){
        b=2000;
        System.out.println("m2给b赋值");
        try{
            Thread.sleep(1000);
            System.out.println("m2睡醒");
        }catch(Exception e){
            e.printStackTrace();
        }
        System.out.println("m2中b="+b);
    }

    public void run(){
        try{
            m1();
        }catch(Exception e){
            e.printStackTrace();
        }
    }

    public static void main(String args[]){
        TT tt = new TT();
        tt.start();
        try {
            TimeUnit.MILLISECONDS.sleep(1000);
        } catch (InterruptedException e1) {
        // TODO Auto-generated catch block
            e1.printStackTrace();
        }
        System.out.println("m2等待锁");
        tt.m2();
        tt.b=3000;
        System.out.println("main中b="+tt.b);
    }

结果:
数值更新正确，顺序执行的。

m1给b赋值
m2等待锁
m1睡醒
m1中b=1000
m2给b赋值
m2睡醒
m2中b=2000
main中b=3000

Process finished with exit code 0

简单总结:
synchronized方法被调用时，要排队一个执行完了才执行下一个。

2.synchronized关键字只加在一个方法上，另一个m2不加。

package com.bgyfw.app.one.backend.api;

import java.util.concurrent.TimeUnit;

public class TT extends Thread {
    int b=100;

    public synchronized void m1(){
        b=1000;
        System.out.println("m1给b赋值");
        try{
            Thread.sleep(2000);
            System.out.println("m1睡醒");
        }catch(Exception e){
            e.printStackTrace();
        }
        System.out.println("m1中b="+b);
    }

    public  void m2(){
        b=2000;
        System.out.println("m2给b赋值");
        try{
            Thread.sleep(1000);
            System.out.println("m2睡醒");
        }catch(Exception e){
            e.printStackTrace();
        }
        System.out.println("m2中b="+b);
    }

    public void run(){
        try{
            m1();
        }catch(Exception e){
            e.printStackTrace();
        }
    }

    public static void main(String args[]){
        TT tt = new TT();
        tt.start();
        try {
            TimeUnit.MILLISECONDS.sleep(1000);
        } catch (InterruptedException e1) {
        // TODO Auto-generated catch block
            e1.printStackTrace();
        }
        System.out.println("m2等待锁");
        tt.m2();
        tt.b=3000;
        System.out.println("main中b="+tt.b);
    }
}

结果:

m1给b赋值
m2等待锁
m2给b赋值
m2睡醒
m2中b=2000
main中b=3000
m1睡醒
m1中b=3000

Process finished with exit code 0

简单总结:
可以看出，m2的执行不受其他synchronized方法影响。但是m1中设置的值会被主线程或者其他线程的值覆盖。在如下，注释掉主线程设置的赋值3000。结果如下：

package com.bgyfw.app.one.backend.api;

import java.util.concurrent.TimeUnit;

public class TT extends Thread {
    int b=100;

    public synchronized void m1(){
        b=1000;
        System.out.println("m1给b赋值");
        try{
            Thread.sleep(2000);
            System.out.println("m1睡醒");
        }catch(Exception e){
            e.printStackTrace();
        }
        System.out.println("m1中b="+b);
    }

    public  void m2(){
        b=2000;
        System.out.println("m2给b赋值");
        try{
            Thread.sleep(1000);
            System.out.println("m2睡醒");
        }catch(Exception e){
            e.printStackTrace();
        }
        System.out.println("m2中b="+b);
    }

    public void run(){
        try{
            m1();
        }catch(Exception e){
            e.printStackTrace();
        }
    }

    public static void main(String args[]){
        TT tt = new TT();
        tt.start();
        try {
            TimeUnit.MILLISECONDS.sleep(1000);
        } catch (InterruptedException e1) {
        // TODO Auto-generated catch block
            e1.printStackTrace();
        }
        System.out.println("m2等待锁");
        tt.m2();
        //tt.b=3000;
        System.out.println("main中b="+tt.b);
    }
}

注释主线程的赋值，结果:

m1给b赋值
m2等待锁
m2给b赋值
m1睡醒
m1中b=2000
m2睡醒
m2中b=2000
main中b=2000

m1的赋值被m2的赋值覆盖。

总结:
当两个synchronized方法同为普通方法或者静态方法时，不能同时调用；否则可以调用。这是因为，当调用synchronized普通方法时，锁住的是当前的this，而调用synchronized锁住的是当前类的字节码；两个方法锁住对象不同，所以可以同时调用。