Java synchronized(同步)用法

KittyGuy
247 阅读4分钟

内容

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

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

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

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

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

  • 无论synchronized关键字加在方法上还是对象上，如果它作用的对象是非静态的，则它取得的锁是对象；如果synchronized作用的对象是一个静态方法或一个类，则它取得的锁是对类，该类所有的对象同一把锁。

  • 每个对象只有一个锁（lock）与之相关联，谁拿到这个锁谁就可以运行它所控制的那段代码。

要点

一般有两种方法bai 同步方法和同步代码块 假设duP1、P2是同一个类的不同对象，zhi这dao个类中定义了以下几种情况的同步块或同步方法，P1、P2就都可以调用它们。
1． 把synchronized当作函数修饰符时，示例代码如下：

Public synchronized void methodAAA()
{
//….
}

这也就是同步方法，那这时synchronized锁定的是哪个对象呢？它锁定的是调用这个同步方法对象。也就是说，当一个对象P1在不同的线程中执行这个同步方法时，它们之间会形成互斥，达到同步的效果。但是这个对象所属的Class所产生的另一对象P2却可以任意调用这个被加了synchronized关键字的方法。 上边的示例代码等同于如下代码： public void methodAAA() { synchronized (this) // (1) { //….. } } (1)处的this指的是什么呢？它指的就是调用这个方法的对象，如P1。可见同步方法实质是将synchronized作用于object reference。――那个拿到了P1对象锁的线程，才可以调用P1的同步方法，而对P2而言，P1这个锁与它毫不相干，程序也可能在这种情形下摆脱同步机制的控制，造成数据混乱：

2．同步块，示例代码如下：

public void method3(SomeObject so)
{
synchronized(so)
{
//…..
}
}

这时，锁就是so这个对象，谁拿到这个锁谁就可以运行它所控制的那段代码。当有一个明确的对象作为锁时，就可以这样写程序，但当没有明确的对象作为锁，只是想让一段代码同步时，可以创建一个特殊的instance变量（它得是一个对象）来充当锁：

class Foo implements Runnable
{
private byte[] lock = new byte[0]; // 特殊的instance变量
Public void methodA()
{
synchronized(lock) { //… }
}
//…..
}

注：零长度的byte数组对象创建起来将比任何对象都经济――查看编译后的字节码：生成零长度的byte[]对象只需3条操作码，而Object lock = new Object()则需要7行操作码。

3．将synchronized作用于static 函数，示例代码如下：

Class Foo
{
public synchronized static void methodAAA() // 同步的static 函数
{
//….
}
public void methodBBB()
{
synchronized(Foo.class) // class literal(类名称字面常量)
}
}

代码中的methodBBB()方法是把class literal作为锁的情况，它和同步的static函数产生的效果是一样的，取得的锁很特别，是当前调用这个方法的对象所属的类（Class，而不再是由这个Class产生的某个具体对象了）。
将 Foo.class和 P1.getClass()用于作同步锁还不一样，不能用P1.getClass()来达到锁这个Class的目的。P1指的是由Foo类产生的对象。
可以推断：如果一个类中定义了一个synchronized的static函数A，也定义了一个synchronized 的instance函数B，那么这个类的同一对象Obj在多线程中分别访问A和B两个方法时，不会构成同步，因为它们的锁都不一样。A方法的锁是Obj这个对象，而B的锁是Obj所属的那个Class。

  • 实现同步是要很大的系统开销作为代价的，甚至可能造成死锁，所以尽量避免无谓的同步控制。

用例

public class BuyTicket {
    public static void main(String[] args) {
        Buy buy = new Buy();
        new Thread(buy,"老王").start();//3个线程同时操作ticketNum，可能会出错，所以要用同步
        new Thread(buy,"老李").start();
        new Thread(buy,"老张").start();
    }
}
class Buy implements Runnable{
    int ticketNum = 1000;
    boolean flag = true;
    @Override
    public void run() {
        while (flag){
            buy();
        }
    }
    synchronized void buy(){//
        try {
            Thread.sleep(0);
            if (ticketNum<=0) {
                flag = false;
                return;
            }
            else{
                System.out.println(Thread.currentThread().getName()+"买到,票还剩"+ticketNum--);
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

    }
}
avatar
文章
阅读
粉丝