synchronized

synchronized是一种同步锁

synchronized是一个比较重量级的操作，对系统的性能有比较大的影响，所以，如果有其他解决方案，通常要避免使用synchronized来解决问题

一、修饰一个代码块

被修饰的代码块称为同步语句块，其作用的范围是大括号{}括起来的代码，作用的对象是调用这个代码块的对象

1.一个线程访问一个对象中的synchronized（this）同步代码块时，其他试图访问该对象的线程将被阻塞

public class SyncThread implements Runnable{
    private static int count;
    public SyncThread(){
        count = 0;
    }
    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 int getCount(){
        return count;
    }
    public static void main(String[] args){
        SyncThread syncThread = new SyncThread();
        Thread thread1 = new Thread(syncThread,"syncThread1");
        Thread thread2 = new Thread(syncThread,"syncThread2");
        SyncThread syncThread2 = new SyncThread();
        Thread thread3 = new Thread(syncThread2,"syncThread3");
        thread1.start();
        thread2.start();
        thread3.start();
    }
}
运行结果：

syncThread1:0
syncThread3:1
syncThread1:2
syncThread3:3
syncThread1:4
syncThread3:5
syncThread3:6
syncThread1:7
syncThread1:8
syncThread3:9
syncThread2:10
syncThread2:11
syncThread2:12
syncThread2:13
syncThread2:14

结论：synchronized（this）作用范围是某个实例，另外一个实例不受影响

2.当一个线程访问对象的一个synchronized（this）同步代码块时，另一个线程仍然可以访问该对象中的非synchronized（this）的同步代码块

3.指定给某个对象加锁

public class Account {
    String name;
    float amount;

    public Account(String name, float amount) {
        this.name = name;
        this.amount = amount;
    }
    //存钱
    public void deposit(float amt){
        amount+=amt;
        try {
            Thread.sleep(100);
        }catch (InterruptedException e){
            e.printStackTrace();
        }
    }
    //取钱
    public void withdraw(float amt){
        amount -= amt;
        try {
            Thread.sleep(100);
        }catch (InterruptedException e){
            e.printStackTrace();
        }
    }
    public float getAmount(){
        return amount;
    }
}

public class AccountOperator implements Runnable{
    private Account account;

    public AccountOperator(Account account) {
        this.account = account;
    }

    public void run(){
        synchronized (account){
            account.deposit(500);
            account.withdraw(500);
            System.out.println(Thread.currentThread().getName()+"："+account.getAmount());
        }
    }

    public static void main(String[] args){
        Account account = new Account("zhangsan",10000);
        AccountOperator accountOperator = new AccountOperator(account);
        Thread threads[] = new Thread[5];
        for(int i=0;i<5;i++){
            threads[i] = new Thread(accountOperator,"Thread"+i);
            threads[i].start();
        }
    }
}
结果：

 

Thread0：10000.0
Thread4：10000.0
Thread3：10000.0
Thread2：10000.0
Thread1：10000.0

二、修饰一个方法

synchronized修饰一个方法，就是在方法前面加synchronized，public synchronized void method()。修饰范围是整个函数，也是只对同一个对象起作用

写法一：

public synchronized void method(){}

写法二：

public void method(){

　　synchronized(this){

       }

}

注意：

1.synchronized关键字不能继承

2.定义接口方法时不能使用synchronized关键字

3.构造方法不能使用synchronized关键字，但可以使用synchronized代码块进行同步

三、修饰一个静态方法

静态方法是属于类的，不是属于对象的。同样，synchronized修饰的静态方法锁定的也是这个类的所有对象

public synchronized static void method()

public class StaticSyncThread implements Runnable{
    private static int count;
    public StaticSyncThread(){
        count = 0;
    }
    public synchronized static void method(){
        for(int i=0;i<5;i++){
            try{
                System.out.println(Thread.currentThread().getName()+":"+(count++));
                Thread.sleep(100);
            }catch (Exception e){
                e.printStackTrace();
            }
        }
    }
    public void run(){
        method();
    }
    public int getCount(){
        return count;
    }
    public static void main(String[] args){
        StaticSyncThread syncThread = new StaticSyncThread();
        Thread thread1 = new Thread(syncThread,"syncThread1");
        StaticSyncThread syncThread2 = new StaticSyncThread();
        Thread thread3 = new Thread(syncThread2,"syncThread3");
        thread1.start();
        thread3.start();
    }
}
结果：

syncThread1:0
syncThread1:1
syncThread1:2
syncThread1:3
syncThread1:4
syncThread3:5
syncThread3:6
syncThread3:7
syncThread3:8
syncThread3:9

四、修饰一个类

 

与三效果一样，都是给整个类加锁，作用于这个类的所有对象

class className{

　　public void method(){

　　　　synchronized(className.class){

　　　　}

　　}

}