学习并发编程

JAVA并发编程实战-读书笔记

线程安全性

1. 编写线程安全的代码，核心在于要对状态访问造作进行管理，特别是对共享的和可变的状态的访问（共享：变量可以由多个线程同时访问。可变：变量的值在生命周期中可能会变化）
2. 对象的状态是指存储在状态变量中的数据。对象的状态可能还包括其他依赖对象的域。（eg：某个HashMap的对象状态不仅保存在HashMap本身，还存储在多个Map.entry对象中）
3. 一个对象是是否需要线程安全，取决于它是否被多个线程访问。要使得线程安全，需要采用“同步机制”来实现-》当多个线程访问某个状态变量并且其中有一个线程执行写入操作，必须采用同步机制来协同这些线程对变量的访问。

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

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

import javax.servlet.Servlet;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import java.math.BigInteger;


@ThreadSafe
public class StatelessFacrorizer  implements Servlet {

    public  void service(ServletRequest request, ServletResponse  response){
        BigInteger  i=extractFromRequest(request);
        BigInteger[] factors=factor(i);
        encodeInResponse(response,factors);
    }
}

原子性：

import javax.servlet.Servlet;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import java.math.BigInteger;


@NotThreadSafe
public class StatelessFacrorizer  implements Servlet {
    
    
    private long count=0;

    public long getCount() {
        return count;
    }
    public void service2(ServletRequest request, ServletResponse  response){
        BigInteger  i=extractFromRequest(request);BigInteger  i=extractFromRequest(request);
        BigInteger[] factors=factor(i);
        ++count;
        encodeInResponse(response,factors);
        
    }
}

++count，这个操作并非是原子的，因而它并不会作为一个不可分割的操作来执行。实际，他包含三个独立的操作：

1. 读取count的值
2. 将值增加1
3. 然后将这个值写入count

为了保证线程安全，“先检查后执行”和“读取-修改-写入”等操作必须是原子的。使用AtomicLong类型的变量来统计已处理请求的数量

@ThreadSafe
public class StatelessFacrorizer implements Servlet {


    private final AtomicLong count = new AtomicLong();

    public long getCount() {
        return count;
    }

    public void service2(ServletRequest request, ServletResponse response) {
        BigInteger i = extractFromRequest(request);
        BigInteger i = extractFromRequest(request);
        BigInteger[] factors = factor(i);
        count.incrementAndGet();
        encodeInResponse(response, factors);

    }
}

在java.util.concurrent.atomic包中包含了一些原子变量类，用于实现在数值和对象引用上的原子状态转换，通过AtomicLong来代替long类型的计数器，能够确保所有计数器状态的访问造作都是原子的。

在实际中，尽量使用现有的线程安全对象（例如AtomicLong）来管理类的状态。
要保持状态的一致性，就需要在单个原子操作中更新所有相关的状态变量

1. 内置锁-》可重入
   一种内置的锁机制可以支持原子性：同步代码块。同步代码块包括两部分：一个作为锁的对象引用，一个作为作为由这个锁保护的代码块。
   每个java对象都可以用作一个实现同步的锁，这些锁称为内置锁或者监视器锁。线程在进入到同步代码块之前会自动获得锁，并且在退出同步代码块时自动释放锁。获得内置锁唯一途径就是进入由这个锁保护的同步代码块或方法
   Java的内置锁相当于一个互斥体（互斥锁），这意味着最多只有一个线程能持有这种锁。当线程A尝试获取一个由线程B持有的锁时，线程A必须等待或者阻塞，直到B释放锁。如果B永远不释放，那么A永远等待。
2. 重入
   由于内置锁是可重入的，因此如果某个线程试图获得一个已经由它自己持有的锁，那么这个请求就会成功。重入意味着获取锁的粒度是“线程”而不是“调用”

重入的实现方式：为每个锁关联一个获取计数值和一个所有者线程。当计数器为0时这个锁可以被当作没有被任何线程持有，当线程请求一个未被持有的锁时，JVM会记下锁的持有者，并且将获取计数器置为1。如果同一个线程再次获取这个锁，计数器将递增，而当线程退出代码块时，计数器会相应地递减。当计数器为0时，这个锁将被释放。

public class Widget {

    public synchronized void test() {
        //dosomething
    }
}

public class LoggingWidght extends Widget {
    public synchronized void testSyn() {
        System.out.println(toString + "calling doSomething");
        super.test();
    }
}

由于内置锁不是可重入的，那么这段代码将发生死锁。