Java中Synchronized修饰不同位置的用法

最新推荐文章于 2024-06-21 08:00:00 发布

ivalue2333

最新推荐文章于 2024-06-21 08:00:00 发布

阅读量4.8k

点赞数

分类专栏： Java 文章标签： java 线程 synchronized

Java 专栏收录该内容

4 篇文章 0 订阅

订阅专栏

  synchronized是Java中的关键字，是一种同步锁。它修饰的对象有以下几种： 

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

  2. 修饰一个方法，被修饰的方法称为同步方法，其作用的范围是整个方法，作用的对象是调用这个方法的对象； 

  3. 修改一个静态的方法，其作用的范围是整个静态方法，作用的对象是这个类的所有对象； 

  4. 修改一个类，其作用的范围是synchronized后面括号括起来的部分，作用的对象是这个类的所有对象。 

  此文转载自：http://blog.csdn.net/luoweifu/article/details/46613015 

 
 1: 修饰一个代码块 

/**
 * demo1: synchronized的用法
 * 一个线程访问一个对象中的synchronized(this)同步代码块时，其他试图访问该对象的线程将被阻塞
 */
public class SyncThread extends Thread {

    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 (InterruptedException 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");
        thread1.start();
        thread2.start();

        // 会有两把锁， syncThread1 对应一把锁， syncThread2 对应一把锁
//        SyncThread syncThread1 = new SyncThread();
//        SyncThread syncThread2 = new SyncThread();
//        Thread thread1 = new Thread(syncThread1, "SyncThread1");
//        Thread thread2 = new Thread(syncThread2, "SyncThread2");
//        thread1.start();
//        thread2.start();
    }
}

/**
 * demo2 多个线程访问synchronized和非synchronized代码块
 * 代码中countAdd是一个synchronized的，printCount是非synchronized的。
 * 从结果中可以看出一个线程访问一个对象的synchronized代码块时，
 * 别的线程可以访问该对象的非synchronized代码块而不受阻塞。
 */
public class Counter implements Runnable {

    private int count;

    public Counter() {
        count = 0;
    }

    public void countAdd() {
        synchronized(this) {
            for (int i = 0; i < 5; i ++) {
                try {
                    System.out.println(Thread.currentThread().getName() + ":" + (count++));
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    //非synchronized代码块，未对count进行读写操作，所以可以不用synchronized
    public void printCount() {
        for (int i = 0; i < 5; i ++) {
            try {
                System.out.println(Thread.currentThread().getName() + " count:" + count);
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public void run() {
        String threadName = Thread.currentThread().getName();
        if (threadName.equals("A")) {
            countAdd();
        } else if (threadName.equals("B")) {
            printCount();
        }
    }

    public static void main(String[] args) {
        Counter counter = new Counter();
        Thread thread1 = new Thread(counter, "A");
        Thread thread2 = new Thread(counter, "B");
        thread1.start();
        thread2.start();
    }
}

/**
 * demo3 :指定要给某个对象加锁
 * 在AccountOperator 类中的run方法里，我们用synchronized 给account对象加了锁。
 * 这时，当一个线程访问account对象时，其他试图访问account对象的线程将会阻塞，
 * 直到该线程访问account对象结束。也就是说谁拿到那个锁谁就可以运行它所控制的那段代码。
 */
public class Demo3 {

    /**
     * 银行账户类
     */
    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 getBalance() {
            return amount;
        }
    }

    /**
     * 账户操作类
     */
    class AccountOperator implements Runnable{
        private Account account;

        private byte[] bytes = new byte[0];

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

        @Override
        public void run() {
            synchronized (account) {
                account.deposit(500);
                account.withdraw(500);
                System.out.println(Thread.currentThread().getName() + ":" + account.getBalance());
            }
//            account.deposit(500);
//            try {
//                Thread.sleep(1000);
//            } catch (InterruptedException e) {
//                e.printStackTrace();
//            }
//            account.withdraw(500);
//            System.out.println(Thread.currentThread().getName() + ":" + account.getBalance());
        }
    }

    public void test() {
        Account account = new Account("zhang san", 10000.0f);
        AccountOperator accountOperator = new AccountOperator(account);

        final int num = 5;
        Thread threads[] = new Thread[num];
        for (int i = 0; i < num; i ++) {
            threads[i] = new Thread(accountOperator, "Thread" + i);
            threads[i].start();
        }
    }

    public static void main(String[] args) {
      Demo3 d = new Demo3();
      d.test();
    }

}

2：修饰一个方法

/**
 * demo4 : 修饰一个方法
 * Synchronized修饰一个方法很简单，
 * 就是在方法的前面加synchronized，public synchronized void method(){};
 * synchronized修饰方法和修饰一个代码块类似，只是作用范围不一样，
 * 修饰代码块是大括号括起来的范围，而修饰方法范围是整个函数
 */

/**
 * 虽然可以使用synchronized来定义方法，但synchronized并不属于方法定义的一部分，
 * 因此，synchronized关键字不能被继承。如果在父类中的某个方法使用了synchronized关键字，
 * 而在子类中覆盖了这个方法，在子类中的这个方法默认情况下并不是同步的，
 * 而必须显式地在子类的这个方法中加上synchronized关键字才可以。当然，
 * 还可以在子类方法中调用父类中相应的方法，这样虽然子类中的方法不是同步的，但子类调用了父类的同步方法，
 * 因此，子类的方法也就相当于同步了。
 */
public class Demo4 extends Thread {

    private static int count;

    public Demo4() {
        count = 0;
    }

    @Override
    public synchronized void run() {
        for (int i = 0; i < 5; i ++) {
            try {
                System.out.println(Thread.currentThread().getName() + ":" + (count++));
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

3：修饰一个静态的方法

/**
 * demo5 :  修饰一个静态的方法，其作用的范围是整个静态方法，作用的对象是这个类的所有对象； 
 * 我们知道静态方法是属于类的而不属于对象的。同样的，synchronized修饰的静态方法锁定的是这个类的所有对象。
 * 
 */
public class SyncThread1 extends Thread {
    private static int count;

    public SyncThread1() {
        count = 0;
    }

    public synchronized static void method() {
        for (int i = 0; i < 5; i ++) {
            try {
                System.out.println(Thread.currentThread().getName() + ":" + (count++));
                Thread.sleep(900);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public synchronized void run() {
        method();
    }

    public static void main(String[] args) {
        SyncThread1 s1 = new SyncThread1();
        SyncThread1 s2 = new SyncThread1();
        //直接这样运行当前线程是main
        //s1.run();

//        Thread t1 = new Thread(s1, "线程1");
//        Thread t2 = new Thread(s1, "线程2");
//        t1.start();
//        t2.start();

        Thread t1 = new Thread(s1, "线程1");
        Thread t2 = new Thread(s2, "线程2");
        t1.start();
        t2.start();
    }
}

4：修饰一个类

/**
 * ynchronized作用于一个类T时，是给这个类T加锁，T的所有对象用的是同一把锁
 */
public class SyncThread2 implements Runnable {

    private static int count;

    public SyncThread2() {
        count = 0;
    }

    public static void method() {
        synchronized(SyncThread2.class) {
            for (int i = 0; i < 5; i ++) {
                try {
                    System.out.println(Thread.currentThread().getName() + ":" + (count++));
                    Thread.sleep(800);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    public synchronized void run() {
        method();
    }

    public static void main(String[] args) {
        // 省略
    }
}

A. 无论synchronized关键字加在方法上还是对象上，如果它作用的对象是非静态的，则它取得的锁是对象；如果synchronized作用的对象是一个静态方法或一个类，则它取得的锁是对类，该类所有的对象同一把锁。
B. 每个对象只有一个锁（lock）与之相关联，谁拿到这个锁谁就可以运行它所控制的那段代码。
C. 实现同步是要很大的系统开销作为代价的，甚至可能造成死锁，所以尽量避免无谓的同步控制。