devbox
菜鸟追梦旅行
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

Java并发编程 并发安全 线程安全性 保证线程安全的几种方法_线程安全的类只能保证在一个方法下线程安全,多个方法调用

作者：菜鸟追梦旅行 | 2024-05-12 20:57:15

赞

踩

线程安全的类只能保证在一个方法下线程安全,多个方法调用

什么是线程安全性

在《Java 并发编程实战》中，定义如下：

当多个线程访问某个类时，不管运行时环境采用何种调度方式或者这些线程将如何交替执行，并且在调用代码中不需要任何额外的同步或者协同，这个类都能表现出正确的行为，那么就称这个类是线程安全的。

线程封闭

实现好的并发是一件困难的事情，所以很多时候我们都想躲避并发。避免并发最简单的方法就是线程封闭。什么是线程封闭呢？
就是把对象封装到一个线程里，只有这一个线程能看到此对象。那么这个对象就算不是线程安全的也不会出现任何安全问题。实现线程封闭有哪些方法呢？

ad-hoc线程封闭
这是完全靠实现者控制的线程封闭，他的线程封闭完全靠实现者实现。 Ad-hoc 线程封闭非常脆弱，应该尽量避免使用。

栈封闭
栈封闭是我们编程当中遇到的最多的线程封闭。
什么是栈封闭呢？
简单的说 就是局部变量。多个线程访问一个方法，此方法中的局部变量都会被拷贝一份到 线程栈中。所以局部变量是不被多个线程所共享的，也就不会出现并发问题。所以能用局部变量就别用全局的变量，全局变量容易引起并发问题。

无状态的类

没有任何成员变量的类，就叫无状态的类，这种类一定是线程安全的。
参见代码：

/**
 1. 无状态的类
 */
public class StatelessClass {
	public int service(int a,int b){
	    return a+b;
    }

    public void serviceUser(UserVo user){
        //do sth user
    }
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12

如果这个类的方法参数中使用了对象，也是线程安全的吗？比如：
在这里插入图片描述
当然也是，为何？因为多线程下的使用，固然 user 这个对象的实例会不正 常，但是对于 StatelessClass 这个类的对象实例来说，它并不持有 UserVo 的对象 实例，它自己并不会有问题，有问题的是 UserVo 这个类，而非 StatelessClass 本身。

让类不可变

让状态不可变，两种方式：

  1. 加 final 关键字，对于一个类，所有的成员变量应该是私有的，同样的只 要有可能，所有的成员变量应该加上 final 关键字，但是加上 final，要注意如果 成员变量又是一个对象时，这个对象所对应的类也要是不可变，才能保证整个类 是不可变的。
    参见代码：
/**
 1. 类不可变
 */
public class ImmutableClass {
    private final int a;
    private final UserVo user = new UserVo();//不安全

	public int getA() {
		return a;
	}
	public UserVo getUser() {
		return user;
	}
	public ImmutableClass(int a) {
		this.a = a;
	}
	public static class User{
    	private int age;

		public int getAge() {
			return age;
		}
		public void setAge(int age) {
			this.age = age;
		}
    }
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  1. 根本就不提供任何可供修改成员变量的地方，同时成员变量也不作为方 法的返回值。
    参见代码：
/**
 * 类不可变--事实不可变
 */
public class ImmutableClassToo {
    private final List<Integer> list = new ArrayList<>(3);

    public ImmutableClassToo() {
        list.add(1);
        list.add(2);
        list.add(3);
    }

    public boolean isContain(int i){
        return list.contains(i);
    }
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16

但是要注意，一旦类的成员变量中有对象，上述的 final 关键字保证不可变并不能保证类的安全性，为何？
因为在多线程下，虽然对象的引用不可变，但是 对象在堆上的实例是有可能被多个线程同时修改的，没有正确处理的情况下，对 象实例在堆中的数据是不可预知的。这就牵涉到了如何安全的发布对象这个问题。
在这里插入图片描述

volatile

并不能保证类的线程安全性，只能保证类的可见性，最适合一个线程写，多个线程读的情景。

加锁和CAS

我们最常使用的保证线程安全的手段，使用 synchronized 关键字，使用显式 锁，使用各种原子变量，修改数据时使用 CAS 机制等等。

安全的发布

类中持有的成员变量，如果是基本类型，发布出去，并没有关系，因为发布 出去的其实是这个变量的一个副本
参见代码：

/**
 * 演示基本类型的发布
 */
public class SafePublish {
	private int i;

    public SafePublish() {
    	i = 2;
    }
	public int getI() {
		return i;
	}
	public static void main(String[] args) {
		SafePublish safePublish = new SafePublish();
		int j = safePublish.getI();
		System.out.println("before j="+j);
		j = 3;
		System.out.println("after j="+j);
		System.out.println("getI = "+safePublish.getI());
	}
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21

但是如果类中持有的成员变量是对象的引用，如果这个成员对象不是线程安 全的，通过 get 等方法发布出去，会造成这个成员对象本身持有的数据在多线程 下不正确的修改，从而造成整个类线程不安全的问题。
参见代码

/**
 * 不安全的发布
 */
public class UnSafePublish {
	private List<Integer> list = new ArrayList<>(3);
	
    public UnSafePublish() {
    	list.add(1);
    	list.add(2);
    	list.add(3);
    }
	
	public List getList() {
		return list;
	}

	public static void main(String[] args) {
		UnSafePublish unSafePublish = new UnSafePublish();
		List<Integer> list = unSafePublish.getList();
		System.out.println(list);
		list.add(4);
		System.out.println(list);
		System.out.println(unSafePublish.getList());
	}
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25

在这里插入图片描述
这个 list 发布出去后，是可以被外部线程之间修改，那么在多个线程同时修 改的情况下不安全问题是肯定存在的，怎么修正这个问题呢？我们在发布这对象 出去的时候，就应该用线程安全的方式包装这个对象。
参见代码：

/**
 1. 安全的发布
 */
public class SafePublishToo {
    private List<Integer> list
            = Collections.synchronizedList(new ArrayList<>(3));

    public SafePublishToo() {
        list.add(1);
        list.add(2);
        list.add(3);
    }

    public List getList() {
        return list;
    }

    public static void main(String[] args) {
        SafePublishToo safePublishToo = new SafePublishToo();
        List<Integer> list = safePublishToo.getList();
        System.out.println(list);
        list.add(4);
        System.out.println(list);
        System.out.println(safePublishToo.getList());
    }
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26

我们将 list 用 Collections.synchronizedList 进行包装以后，无论多少线程使用这个 list，就都是线 程安全的了。
在这里插入图片描述
对于我们自己使用或者声明的类，JDK 自然没有提供这种包装类的办法，但 是我们可以仿造这种模式或者委托给线程安全的类，当然，对这种通过 get 等方 法发布出去的对象，最根本的解决办法还是应该在实现上就考虑到线程安全问题

另外对容器的包装

/**
 * 仿Collections对容器的包装，将内部成员对象进行线程安全包装
 */
public class SoftPublicUser {
    private final UserVo user;

    public UserVo getUser() {
        return user;
    }

    public SoftPublicUser(UserVo user) {
        this.user = new SynUser(user);
    }

    private static class SynUser extends UserVo{
        private final UserVo userVo;
        private final Object lock = new Object();

        public SynUser(UserVo userVo) {
            this.userVo = userVo;
        }

        @Override
        public int getAge() {
            synchronized (lock){
                return userVo.getAge();
            }
        }

        @Override
        public void setAge(int age) {
            synchronized (lock){
                userVo.setAge(age);
            }
        }
    }

}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
/**
 * 类说明：委托给线程安全的类来做
 */
public class SafePublicFinalUser {
    private final SynFinalUser user;

    public SynFinalUser getUser() {
        return user;
    }

    public SafePublicFinalUser(FinalUserVo user) {
        this.user = new SynFinalUser(user);
    }

    public static class SynFinalUser{
        private final FinalUserVo userVo;
        private final Object lock = new Object();

        public SynFinalUser(FinalUserVo userVo) {
            this.userVo = userVo;
        }

        public int getAge() {
            synchronized (lock){
                return userVo.getAge();
            }
        }

        public void setAge(int age) {
            synchronized (lock){
                userVo.setAge(age);
            }
        }
    }

}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36

TheadLocal

ThreadLocal 是实现线程封闭的最好方法。 ThreadLocal 内部维护了一个 Map， Map 的 key 是每个线程的名称，而 Map 的值就是我们要封闭的对象。每个线程 中的对象都对应着 Map 中一个值，也就是 ThreadLocal 利用 Map 实现了对象的线程封闭。

Servlet辨析

不是线程安全的类，为什么我们平时没感觉到：

  1. 在需求上，很少有共享的需求
  2. 接收到了请求，返回应答的时候，一 般都是由一个线程来负责的。 但是只要 Servlet 中有成员变量，一旦有多线程下的写，就很容易产生线程安全问题。
声明：本文内容由网友自发贡献，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：【wpsshop博客】
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号