首页 > 代码库 > synchronized将任意对象作为对象监视器

synchronized将任意对象作为对象监视器

2024-09-01 17:03:35   218人阅读

多个线程调用同一个对象中的不同名称的synchronized同步方法或synchronized(this)同步代码块时，调用的效果就是按顺序执行，也就是同步的，阻塞的。
这说明synchronized同步方法或synchronized(this)同步代码块分别有两种作用
（1）synchronized同步方法
1）对其他synchronized同步方法或synchronized(this)同步代码块调用呈阻塞状态
2）同一时间只有一个线程可以执行synchronized同步方法中的代码
（2）synchronized(this)同步代码块
1）对其他synchronized同步方法或synchronized(this)同步代码块调用呈阻塞状态
2）同一时间只有一个线程可以执行synchronized(this)同步代码块中的代码
Java还支持对“任意对象”作为“对象监视器”来实现同步的功能。这个“任意对象”大多数是实例变量及方法的参数，使用synchronized(非this对象)
synchronized(非this对象)格式的作用只有1中：synchronized(非this对象x)同步代码块
1）在多个线程持有“对象监视器”为同一个对象的前提下，同一时间只有一个线程可以执行synchronized(非this对象x)同步代码块中的代码
2）当持有“对象监视器”为同一个对象的前提下，同一时间只有一个线程可以执行synchronized(非this对象x)同步代码块中的代码。
package synBlockString;

/**
 * Created by Administrator on 2017/1/19 0019.
 */
public class Service {
    private String usernameParam;
    private String passwordParam;
    private String anyString = new String();
    public void setUsernamePassword(String username,String password){
        try{
            synchronized (anyString){
                System.out.println("线程名称为："+Thread.currentThread().getName()+"在"+System.currentTimeMillis()+"进入同步");
                usernameParam = username;
                Thread.sleep(2000);
                passwordParam = password;
                System.out.println("线程名称为："+Thread.currentThread().getName()+"在"+System.currentTimeMillis()+"离开同步");
            }
        }catch(InterruptedException e){
            e.printStackTrace();
        }
    }
}
package synBlockString;

/**
 * Created by Administrator on 2017/1/19 0019.
 */
public class ThreadA extends Thread {
    private Service service;
    public ThreadA(Service service){
        super();
        this.service = service;
    }

    public void run(){
        service.setUsernamePassword("a","aa");
    }
}
package synBlockString;

/**
 * Created by Administrator on 2017/1/19 0019.
 */
public class ThreadB extends Thread {
    private Service service;
    public ThreadB(Service service){
        super();
        this.service = service;
    }
    public void run(){
        service.setUsernamePassword("b","bb");
    }

}
package synBlockString;



/**
 * Created by Administrator on 2017/1/19 0019.
 */
public class Run {
    public static void main(String [] args){
        Service service = new Service();
        ThreadA threadA = new ThreadA(service);
        threadA.setName("A");
        threadA.start();
        ThreadB threadB = new ThreadB(service);
        threadB.setName("B");
        threadB.start();
        threadB.start();

    }
}
线程名称为：A在1484823811547进入同步
线程名称为：A在1484823813559离开同步
线程名称为：B在1484823813559进入同步
线程名称为：B在1484823815573离开同步

如果修改service.java为

package synBlockString;

/**
 * Created by Administrator on 2017/1/19 0019.
 */
public class Service {
    private String usernameParam;
    private String passwordParam;

    public void setUsernamePassword(String username,String password){
        try{
            String anyString = new String();
            synchronized (anyString){
                System.out.println("线程名称为："+Thread.currentThread().getName()+"在"+System.currentTimeMillis()+"进入同步");
                usernameParam = username;
                Thread.sleep(2000);
                passwordParam = password;
                System.out.println("线程名称为："+Thread.currentThread().getName()+"在"+System.currentTimeMillis()+"离开同步");
            }
        }catch(InterruptedException e){
            e.printStackTrace();
        }
    }
}
线程名称为：A在1484823870625进入同步
线程名称为：B在1484823870625进入同步
线程名称为：B在1484823872638离开同步
线程名称为：A在1484823872638离开同步

所以，使用synchronized(非this对象)同步代码块格式进行同步操作时，对象监视器必须是同一个对象，如果不是同一个对象监视器，运行的结果就是异步调用了，就会交叉运行。

再看下一个示例：

package synBlockString2;


/**
 * Created by Administrator on 2017/1/19 0019.
 */
public class Service  {
    private String anyThing = new String();
    public void a(){
        try {
            synchronized (anyThing){
                System.out.println("a begin");
                Thread.sleep(2000);
                System.out.println("a end");
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    synchronized  public void b(){
        System.out.println(" b begin");
        System.out.println(" b end");
    }
}
package synBlockString2;

/**
 * Created by Administrator on 2017/1/19 0019.
 */
public class ThreadA extends Thread {
    private Service service;
    public ThreadA(Service service){
        super();
        this.service = service;
    }
    public  void run(){
        service.a();
    }
}
package synBlockString2;

/**
 * Created by Administrator on 2017/1/19 0019.
 */
public class ThreadB extends Thread {
    private Service service;
    public ThreadB(Service service){
        super();
        this.service = service ;
    }
    public void run(){
        service.b();
    }
}
package synBlockString2;

/**
 * Created by Administrator on 2017/1/19 0019.
 */
public class Run {
    public static void main(String [] args){
        Service service = new Service();
        ThreadA threadA = new ThreadA(service);
        threadA.setName("A");
        threadA.start();
        ThreadB threadB = new ThreadB(service);
        threadB.setName("B");
        threadB.start();
    }
}
运行结果：
a begin
 b begin
 b end
a end

由于对象监视器不同，所以运行结果就是异步的

同步代码块放在非同步synchronized方法中进行声明，并不能保证调用方法的线程的执行同步/顺序性，也就是线程调用方法的顺序是无序的，虽然在同步块中执行的顺序是同步的，这样就容易出现脏读问题。

synchronized将任意对象作为对象监视器


联系
我们