多线程安全 synchronized使用

我们在写一个单例模式的管理类时都会这样写

public class ConfigManager {
    private static ConfigManager instance;
    private ConfigManager(){}
    public static synchronized ConfigManager getInstance(){
        if(instance==null){
            instance=new ConfigManager();
        }
        return instance;
    }
    public static ConfigManager getInstanceUseDoubleLock(){
        if(instance==null){
            synchronized (ConfigManager.class){
                if(instance==null){
                    instance=new ConfigManager();
                }
            }
        }
        return instance;
    }
}

上面的线程安全有两种写法,一个是在方法上加synchronized,一个是在代码块中加上synchronized,这两个有方法加上synchronized有什么用,又有什么区别呢?
1.一个类如下:

public class UserManager {
    private User user;
    public UserManager(User user) {
        this.user = user;
    }
    public void updateUser(User newUser){
        user.setName(newUser.getName());
        user.setGender(newUser.getGender());
    }
}

2.创建一个User类

public class User {
    private String name;
    private String gender;
    public User() {}
    public User(String name, String gender) {
        this.name = name;
        this.gender = gender;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getGender() {
        return gender;
    }
    public void setGender(String gender) {
        this.gender = gender;
    }
    @Override
    public String toString() {
        return "User{" + "name='" + name + '\'' + ", gender='" + gender + '\'' + '}';
    }
}

3.开启两个线程

 private User user;
 private UserManager userManager;
 user = new User();
 userManager = new UserManager(user);
//线程一
        new Thread(new Runnable() {
            @Override
            public void run() {
                User user1=new User("Tom","男");
                userManager.updateUser(user1);
            }
        }).start();
        //线程二
        new Thread(new Runnable() {
            @Override
            public void run() {
                User user2=new User("凤姐","女");
                userManager.updateUser(user2);
            }
        }).start();
      Log.e("user----",user.toString());   
        

4.结果:
线程一:name="Tom";
线程二:name="凤姐";
线程二:gender="女";
线程一:gender="男";
结果:name="凤姐",gender="男"

结果数据混乱了

使用synchronized解决方法

 public synchronized void updateUser(User newUser){
        user.setName(newUser.getName());
        user.setGender(newUser.getGender());
    }

有一个场景:新增一个printUser方法

public synchronized void updateUser(User newUser){
        user.setName(newUser.getName());
        user.setGender(newUser.getGender());
    }
public synchronized void printUser(){
        Log.e("UserManager--","name:"+user.getName()+"--gender:"+user.getGender());
    }

updateUser和printUser方法上都加上锁synchronized,这个时候updateUser方法调用时,线程中printUser方法不会调用的,可以确保我的信息写入完之后,我才能读取,

现在有一个场景需求:我想新加一个方法,两个方法同时进行,互不影响

如下:

public class UserManager {
    private User user;
    private final Object monitor2=new Object();
    public UserManager(User user) {
        this.user = user;
    }
    public synchronized void updateUser(User newUser){
        user.setName(newUser.getName());
        user.setGender(newUser.getGender());
    }
    public synchronized void printUser(){
        Log.e("UserManager--","name:"+user.getName()+"--gender:"+user.getGender());
    }
    /**
     * 现在新增的其他方法也加上锁synchronized,这样会导致其他必须在上面的updateUser调用完毕才能执行,
     * 这样我想调用otherMethod必须在此之后,不符合实际
     */
    public void otherMethod(){
        synchronized (monitor2){
            Log.e("UserManager--","同时调用第二个方法");
        }
    }
}

synchronized在两个方法加入的位置不一样,有什么区别呢?

updateUser()和printUser()方法在方法上加上锁,此时它们有系统提供的默认管理者monitor在管理,当updateUser()进去线程管理后,printUser()是不能进去了,所以这个方法不调用, 而otherMethod()方法在代码块里添加一个自己创建的monitor2,会管理自己的方法,所以不受上面的影响。

注意:线程不安全是因为数据读取中,进行write写入或者write写入中有读取,如果两个线程都是读取不会存在线程安全问题

你可能感兴趣的:(多线程安全 synchronized使用)