Java并发编程实战--笔记一

最新推荐文章于 2024-08-24 20:23:05 发布

衣舞晨风

最新推荐文章于 2024-08-24 20:23:05 发布

阅读量1.8k

点赞数

分类专栏： Java Java 进阶文章标签： java 编程并发实战笔记

本文链接：https://blog.csdn.net/jiankunking/article/details/72857046

版权

Java 同时被 2 个专栏收录

89 篇文章 16 订阅

订阅专栏

Java 进阶

62 篇文章 11 订阅

订阅专栏

第1-3章（线程安全性、对象的共享、对象的组合）

无状态对象一定是线程安全的。

要保持状态的一致性，就需要在单个原子操作中更新所有相关的状态变量。

synchronized修饰方法表示：在同一时刻，只有一个线程可以执行该方法。

“重入”意味着获取锁的操作的粒度是”线程”，而不是调用。重入的一种实现方法是，为每一个锁关联一个获取计数值和一个所有者线程。当计数值为0时，这个锁就被认为是没有被任何线程所持有，当线程请求一个未被持有的锁时，JVM将记下锁的持有者，并且将获取计数值置为1，如果同一个线程再次获取这个锁，计数值将递增，而当线程退出同步代码块时，计数器会相应地递减。当计数值为0时，这个锁将被释放。

如果用同步来协调对某个变量的访问，那么在访问这个变量的所有位置上都需要使用同步。而且，当使用锁来协调多某个变量的访问时，在访问变量的所有位置上都要使用同一个锁。

对于可能被多个线程同时访问的可变状态变量，在访问它时都需要持有同一个锁，在这种情况下，我们称状态变量是由这个锁保护。

加锁的含义不仅仅局限于互斥行为，还包括内存可见性。为了确保所有线程都看到共享变量的最新值，所有执行读操作或者写操作的线程都必须在同一个锁上同步。

不要在构造过程中使this引用溢出
http://blog.csdn.net/jiankunking/article/details/72857031

ThreadLocal对象通常用于防止对可变的单实例变量或全局变量进行共享。
假设你需要将一个单线程应用程序移植到多线程环境中，通过将共享的全局变量转换为ThreadLocal对象（如果全局变量的语义允许），可以维持线程安全性。

ThreadLocal变量类似于全局变量，它能降低代码的可重用性，并在类之间引入隐含的耦合性，因此在使用时要格外小心。

当满足以下条件时，对象才是不可变的：

1、对象创建完之后其状态就不能修改

2、对象的所有与都是 final 类型

3、对象时正确创建的（创建期间没有 this 的逸出）

final类型的域是不能修改的，除了这一点外，在Java内存模型中，final域还有着特殊的语义，final域能确保初始化过程的安全性，从而可以不受限制地访问不可变对象，并在共享这些对象时无须同步。具体而言，就是被final修饰的字段在构造器中一旦被初始化完成，并且构造器没有把“this”的引用传递出去（this引用逃逸是一件很危险的事情，其他线程有可能通过这个引用访问到“初始化了一半”的对象），那么在其他线程中就能看到final字段的值，而且其外、外部可见状态永远也不会改变。它所带来的安全性是最简单最纯粹的。

正如“除非需要更高的可见性，否则应将所有的域都声明为私有域”是一个良好的编程习惯，“除非需要某个域是可变的，否则应将其声明为final域”也是一个良好的编程习惯。

许多人担心这种方式会带来性能问题，但这是没必要的。内存分配的开销比你想象的还要低，并且不可变对象还会带来其他优势，例如：减少了对加锁或者保护性副本的需求，以及降低对基于“代”的垃圾收集机制的影响。

即使某个对象的引用对其他线程是可见的，也并不意味着对象状态对于使用该对象的线程来说一定是可见的。为了确保对象状态能呈现出一致的视图，就必须使用同步。

任何线程都可以在不需要额外同步的情况下安全地访问不可改变对象，即使在发布这些对象时没有使用同步。

安全地发布一个对象，对象的应用以及对象的状态必须同时对其他线程可见。一个正确构造的对象可以通过以下方式来安全地发布：

1、在静态初始化函数中初始化一个对象引用

2、将对象的应用保存到volatile类型的域或者AtomicReferance对象中

3、将对象的引用保存到某个正确构造对象的final类型域中

4、将对象的引用保存到一个由锁保护的域中。

在线程安全容器内部的同步意味着，在将对象放入到某个容器，例如Vector或synchronizedList时，将满足上述最后一条需求。如果线程A将对象X放入一个线程安全的容器，随后线程B读取这个对象，那么可以确保B看到A设置的X状态，即便在这段读/写X的应用程序代码中没有包含显式的同步。尽管Javadoc在这个主题上没有给出很清晰的说明，但线程安全库中的容器类提供了以下的安全发布保证：

1、通过将一个键或者值放入Hashtable、synchronizedMap或者ConcurrentMap中，可以安全地将它发布给任何从这些容器中访问它的线程（无论是直接访问还是通过迭代器访问）

2、通过将某个元素放入Vector、CopyOnWriteArrayList、CopyOnWriteArraySet、synchronizedList或synchronizedSet中，可以将该元素安全地发布到任何从这些容器中访问该元素的线程

3、通过将某个元素放入BlockingQueue或者ConcurrentLinkedQueue中，可以将该元素安全地发布到任何从这些队列中访问该元素的线程。

类库中的其他数据传递机制（例如Future和Exchanger）同样能实现安全发布。

通常，要发布一个静态构造的对象，最简单和最安全的方式是使用静态的初始化器：

public static Holder holder = new Holder(42);

静态初始化器由JVM在类的初始化阶段执行。由于在JVM内部存在着同步机制，因此通过这种方式初始化的任何对象都可以被安全地发布[JLS 12.4.2]。

对象的发布需求取决于它的可变性：

1、不可变对象可以通过任意机制来发布

2、事实不可改变必须通过安全方式发布

3、可变对象必须通过安全方式发布，并且必须是线程安全的或者由某个锁保护起来、

第4章：对象的组合

如果在一个不变性条件中包含多个变量，那么在执行任何访问相关变量的操作时操作时，都必须持有保护这些变量的锁。

将数据封装在对象内部，可以将数据的访问限制在对象的方法上，从而更容易确保线程在访问数据时总能持有正确的锁。

客户端加锁是指：对于使用某个对象X的客户端代码，使用X本身用于保护其状态的锁来保护这段客户代码。要使用客户端加锁，你必须知道对象X使用的是哪一个锁。

public class ListHelper<E> {
    public List<E> list = Collections.synchronizedList(new ArrayList<E>());
    public boolean putIfAbsent(E x) {
        synchronized(list) {
            boolean absent = !list.contains(x);
            if (absent) {
                list.add(x);
            }
            return absent;
        }
    }
}
//推荐
public class ImprovedList<T> implements List<T> {
    private final List<T> list;
    public ImprovedList(List<T> list) {
        this.list = list;
    }
    public synchronized boolean putIfAbsent(T x) {
        boolean absent = !list.contains(x);
        if (absent) {
            list.add(x);
        }
        return absent;
    }
    //...按照类似的方式将ImprovedList的其他方法实现委托给List
}