Java并发(一):基础概念

　　对于Java并发,我也是属初学阶段,用的参考书是:"Java并发编程实战",写博时也参考了很多类似主题的博客,博主意在记录自己的学习路程,供网友讨论学习之用;

　　周末写的差不多了,今天下午没事正好整理一下,Java并发两篇一起发了;

　　

先介绍一下线程的概念(摘自百度百科):

　　　　线程，有时被称为轻量进程(Lightweight Process，LWP），是程序执行流的最小单元。一个标准的线程由线程ID，当前指令指针(PC），寄存器集合和堆栈组成。另外，线程是进程中的一个实体，是被系统独立调度和分派的基本单位，线程自己不拥有系统资源，只拥有一点儿在运行中必不可少的资源，但它可与同属一个进程的其它线程共享进程所拥有的全部资源。一个线程可以创建和撤消另一个线程，同一进程中的多个线程之间可以并发执行。由于线程之间的相互制约，致使线程在运行中呈现出间断性。线程也有就绪、阻塞和运行三种基本状态。就绪状态是指线程具备运行的所有条件，逻辑上可以运行，在等待处理机；运行状态是指线程占有处理机正在运行；阻塞状态是指线程在等待一个事件（如某个信号量），逻辑上不可执行。每一个程序都至少有一个线程，若程序只有一个线程，那就是程序本身。

　　　　线程是程序中一个单一的顺序控制流程。进程内有一个相对独立的、可调度的执行单元，是系统独立调度和分派CPU的基本单位指令运行时的程序的调度单位。在单个程序中同时运行多个线程完成不同的工作，称为多线程。

　　　　每个线程都拥有一个栈和一个程序计数器,来保存线程执行历史和执行状态,是线程的私有资源,而堆,地址空间,全局变量是由一个进程内多个线程共享的公有资源.

 

　　线程的优势:

　　　　1.有效降低程序开发和维护的成本,同时提升复杂应用程序的性能;

　　　　2.线程可以将大部分异步工作流转换成串行工作流,因此能够更好地模拟人类的工作方式和交互方式;

　　　　3.降低代码复杂度,使之更容易编写,阅读和维护;

　　　　4.GUI中,线程可以提高UI的相应灵敏度;

　　　　5.服务器应用中,可以提升资源利用率以及系统吞吐率;

　　　　6.简化JVM实现,GC实现等等.

 

　　线程带来的风险(一篇博文讲不完,之后会详细介绍):

　　　　1.安全性问题:多个线程中的操作执行顺序使不可预测的,甚至会产生奇怪的结果;(存在竞态条件)

　　　　2.活跃性问题:当某个操作无法继续执行下去时,就会发生活跃性问题;(死锁问题等)

　　　　3.性能问题:线程总会带来某种程度的开销;(线程调度器挂起活跃线程并转而运行另一个线程,引起频繁地上下文切换"Context Switch")

 

　　

 

下面展开讲讲安全性相关的基础知识点:

　

//NotThreadSafe
public class UnsafeCountingFactorizer implement Servlet (

        private long count = 0;

        public long getCount() { return count; }

        public void service (ServletRequest req, ServletResponse resp) {
                BigInteger i = extractFromRequest(req);
                BigInteger[] factors = factor(i);
                ++count;
                encodeIntoResponse(resp, factors);
        }
}

　　以上类并非线程安全的,尽管在单线程环境能够正确运行,++count操作包含了三个独立操作:读取count的值,值加1,结果赋给count,这是一个"读取--修改--写入"的操作序列,结果状态依赖于上一个状态;

　　不理想状态下,线程A获取了count的值此时为9,同时线程B也获得了count为9的值,但线程A意外被阻塞了一下,线程B已经完成了++count操作,此时count的值已经为10,错误出现了,线程A获得的count是上个状态的count=9,线程A执行完之后,count依然是9,结果与我们预期(count=11)出现了偏差,此时,称此类拥有"竞态条件",但并不总会产生错误,但不幸的是,运行过程中出现了不恰当的时序,引发了引种的数据完整性问题(失效数据).

　　引出了一个概念,多线程环境下,会有发生并发安全问题的风险,成为竞态条件(Race Condition);

 

　　说到这里不得不提及一个叫无状态的类的概念:一个既不包含任何域,也不包含任何对其他类域的引用的类成为无状态的,计算过程的临时状态仅仅存儲在线程栈上的局部变量中,且只能由正在执行的线程访问,所以无状态对象一定是线程安全的.

 

　　

 

　　那么我们如何解决,或者说如何应对安全性问题呢?

　　要避免竞态条件问题,就必须在某个线程修改该变量时,通过某种方式防止其它线程使用这个变量,这种变量(资源),可以称之为"临界区"（Critical Section）;

 

1.可以让临界资源声明成java.util.concurrent.atomic包中的原子变量类;

//ThreadSafe
public class CountingFactorizer implements Servlet {
        private final AtomicLong count = new AtomicLong(0);

        public long getCOunt() { return count.get(); }

        public void service(ServletRequest req, ServletResponse resp){
                BigInteger i = extractFromRequest(req);
                BigInteger[] factors = factor(i);
                count.incrementAndGet();　　//该操作是原子的,调用时会防止其它线程调用,实现在数值和对象引用的原子状态转换
                encodeIntoResponse(resp, factors);
        }
}

2.可以加锁机制(既可以确保原子性,又可以确保可见性):

　　　　Java提供了一种内置锁（监听器锁）机制来支持原子性：同步代码块（Synchronized Block）:线程在进入同步代码块之前会自动获得锁，并且在推出同步代码块时自动释放锁；

　　　　内置锁：相当于一种互斥锁，意味着最多只能有一个线程能够持有这种锁，故每次只能有一个线程可以执行内置锁保护的代码块，并且内置锁时可重入的；

　　　　这里不得不提”重入“：意味着获取锁的操作的粒度是”线程“，而不是”调用“，即可重入的锁可由一个线程多次调用，若一个内置锁不可重入，则会有死锁的风险。下面是一个例子来说明"可重入":

　　　　

public class Widget {
    public synchronized void doSomething(){
        //TODO
    }

    public class LoggingWidget extends Widget {
        public synchronized void doSomething(){
                super.doSomething();
        }
    }
}

　　　　如果内置锁不是可重入的,那么执行到super.doSomething()时,doSomething()已经被锁住,LoggingWidget中的doSomething()已经无法获得父类中doSomething()的锁,因此进入了无限的等待(死锁);

　　　　如果内置锁时可重入的,那么线程可以多次获得doSomething()的锁,就不会发生死锁.

　　　　当然,并非所有数据都需要锁的保护,只有被多个线程同事访问的可变数据才需要锁的保护;

3.Volatile变量(比锁机制更加轻量,确保了可见性又避免了重排序)

　　　　volatile变量是Java提供的一种稍弱的同步机制,当把变量声明为volatile类型后,编译器与运行时都会注意到这个变量是共享的,因此不会将该变量上的操作与其它内存操作进行重排序(reorder),读取volatile类型的变量时总会返回最新写入的值

　　　　　　

　　　　重排序是什么?

　　　　　　在执行程序时为了提高性能，编译器和处理器常常会对指令做重排序。重排序会遵守数据的依赖性，编译器和处理器不会改变存在数据依赖关系的两个操作的执行顺序。

　　　　　　　　

int a = 0; int b = 0；

　　　　　　翻译成机器指令后并不能保证a = 0操作在b = 0操作之前;

　　　　　　因为编译器、处理器会对指令进行重排序，通常而言，Java源程序变成最后的机器执行指令会经过重排序。

　　　　何时使用volatile?(参考博文的结尾处:https://www.cnblogs.com/dolphin0520/p/3920373.html)

　　　　　　状态标记量;

　　　　　　double check;

　　　　　　例如

volatile boolean asleep = false;

...
    while (!asleep) {
        countSheep();
...

　　　　asleep必须被volatile修饰,变量asleep才能相对各个线程可见,否则进入循环的线程将会将无限循环下去.