Java线程(一)

1. java什么叫线程安全？什么叫不安全？

就是线程同步的意思，就是当一个程序对一个线程安全的方法或者语句进行访问的时候，其他的不能再对他进行操作了，必须等到这次访问结束以后才能对这个线程安全的方法进行访问
什么叫线程安全：
如果你的代码所在的进程中有多个线程在同时运行，而这些线程可能会同时运行这段代码。如果每次运行结果和单线程运行的结果是一样的，而且其他的变量的值也和预期的是一样的，
就是线程安全的。
或者说:一个类或者程序所提供的接口对于线程来说是原子操作或者多个线程之间的切换不会导致该接口的执行结果存在二义性,也就是说我们不用考虑同步的问题。
线程安全问题都是由全局变量及静态变量引起的。
若每个线程中对全局变量、静态变量只有读操作，而无写操作，一般来说，这个全局变量是线程安全的；若有多个线程同时执行写操作，一般都需要考虑线程同步，否则就可能影响线程安全。

存在竞争的线程不安全，不存在竞争的线程就是安全的

1.线程安全(局部变量)

    public static void test1() {
        int i = ;
        i++;
        System.out.println(i);
    }

　　由于i是局部变量，不存在线程安全的问题。100个线程同时访问，每个线程都有自己的i，不会产生线程安全问题。

2.servlet线程不安全(全局变量)

aaarticlea/png;base64,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" alt="" />

　　servlet对象只有一个，i也只有一个，存在线程安全问题。

　　静态成员变量也会存在线程安全，静态成员在类加载器加载的时候执行，多个对象共享同一个静态成员变量，且静态成员变量不会被释放，Java对象会被JVM自动回收，因此静态成员变量需要谨慎使用。比如一个静态list集合，一个服务器启动后会开启多年，list也会存在多年，如果对象向list中添加数据会导致崩溃(list过大)。

2.    浅谈java内存模型
      
不同的平台，内存模型是不一样的，但是jvm的内存模型规范是统一的。其实java的多线程并发问题最终都会反映在java的内存模型上，所谓线程安全无
非是要控制多个线程对某个资源的有序访问或修改。总结java的内存模型，要解决两个主要的问题：可见性和有序性。我们都知道计算机有高速缓存的存在，处
理器并不是每次处理数据都是取内存的。JVM定义了自己的内存模型，屏蔽了底层平台内存管理细节，对于java开发人员，要清楚在jvm内存模型的基础
上，如果解决多线程的可见性和有序性。
       那么，何谓可见性？
多个线程之间是不能互相传递数据通信的，它们之间的沟通只能通过共享变量来进行。Java内存模型（JMM）规定了jvm有主内存，主内存是多个线程共享
的。当new一个对象的时候，也是被分配在主内存中，每个线程都有自己的工作内存，工作内存存储了主存的某些对象的副本，当然线程的工作内存大小是有限制
的。当线程操作某个对象时，执行顺序如下：
 (1) 从主存复制变量到当前工作内存 (read and load)
 (2) 执行代码，改变共享变量值 (use and assign)
 (3) 用工作内存数据刷新主存相关内容 (store and write)

JVM规范定义了线程对主存的操作指令：read，load，use，assign，store，write。当一个共享变量在多个线程的工作内存中都有副本时，如果一个线程修改了这个共享变量，那么其他线程应该能够看到这个被修改后的值，这就是多线程的可见性问题。
        那么，什么是有序性呢
？线程在引用变量时不能直接从主内存中引用,如果线程工作内存中没有该变量,则会从主内存中拷贝一个副本到工作内存中,这个过程为read-load,完
成后线程会引用该副本。当同一线程再度引用该字段时,有可能重新从主存中获取变量副本(read-load-use),也有可能直接引用原来的副本
(use),也就是说 read,load,use顺序可以由JVM实现系统决定。
       
线程不能直接为主存中中字段赋值，它会将值指定给工作内存中的变量副本(assign),完成后这个变量副本会同步到主存储区(store-
write)，至于何时同步过去，根据JVM实现系统决定.有该字段,则会从主内存中将该字段赋值到工作内存中,这个过程为read-load,完成后线
程会引用该变量副本，当同一线程多次重复对字段赋值时,比如：

Java代码

1. for(int i=0;i<10;i++)
2. a++;

for(int i=0;i<10;i++)

a++;

线程有可能只对工作内存中的副本进行赋值,只到最后一次赋值后才同步到主存储区，所以assign,store,weite顺序可以由JVM实现系统决
定。假设有一个共享变量x，线程a执行x=x+1。从上面的描述中可以知道x=x+1并不是一个原子操作，它的执行过程如下：
1 从主存中读取变量x副本到工作内存
2 给x加1
3 将x加1后的值写回主 存
如果另外一个线程b执行x=x-1，执行过程如下：
1 从主存中读取变量x副本到工作内存
2 给x减1
3 将x减1后的值写回主存
那么显然，最终的x的值是不可靠的。假设x现在为10，线程a加1，线程b减1，从表面上看，似乎最终x还是为10，但是多线程情况下会有这种情况发生：
1：线程a从主存读取x副本到工作内存，工作内存中x值为10
2：线程b从主存读取x副本到工作内存，工作内存中x值为10
3：线程a将工作内存中x加1，工作内存中x值为11
4：线程a将x提交主存中，主存中x为11
5：线程b将工作内存中x值减1，工作内存中x值为9
6：线程b将x提交到中主存中，主存中x为9
同样，x有可能为11，如果x是一个银行账户，线程a存款，线程b扣款，显然这样是有严重问题的，要解决这个问题，必须保证线程a和线程b是有序执行的，并且每个线程执行的加1或减1是一个原子操作。

synchronized关键字
        java用synchronized关键字做为多线程并发环境的执行有序性的保证手段之一。当一段代码会修改共享变量，这一段代码成为互斥区或临界区，为了保证共享变量的正确性，synchronized标示了临界区。典型的用法如下：

Java代码

1. synchronized(锁){
2. 临界区代码
3. }

synchronized(锁){

临界区代码

}

理论上，每个对象都可以做为锁，但一个对象做为锁时，应该被多个线程共享，这样才显得有意义，在并发环境下，一个没有共享的对象作为锁是没有意义的。假如有这样的代码：

Java代码

1. public class ThreadTest{
2. public void test(){
3. Object lock=new Object();
4. synchronized (lock){
5. //do something
6. }
7. }
8. }

public class ThreadTest{

public void test(){

Object lock=new Object();

synchronized (lock){

//do something

}

}

}

lock变量作为一个锁存在根本没有意义，因为它根本不是共享对象，每个线程进来都会执行Object lock=new Object();每个线程都有自己的lock，根本不存在锁竞争。
       
每个锁对象都有两个队列，一个是就绪队列，一个是阻塞队列，就绪队列存储了将要获得锁的线程，阻塞队列存储了被阻塞的线程，当一个被线程被唤醒
(notify)后，才会进入到就绪队列，等待cpu的调度。当一开始线程a第一次执行account.add方法时，jvm会检查锁对象account

的就绪队列是否已经有线程在等待，如果有则表明account的锁已经被占用了，由于是第一次运行，account的就绪队列为空，所以线程a获得了锁，
执行account.add方法。如果恰好在这个时候，线程b要执行account.withdraw方法，因为线程a已经获得了锁还没有释放，所以线程
b要进入account的就绪队列，等到得到锁后才可以执行。
一个线程执行临界区代码过程如下：
1 获得同步锁
2 清空工作内存
3 从主存拷贝变量副本到工作内存
4 对这些变量计算
5 将变量从工作内存写回到主存
6 释放锁
可见，synchronized既保证了多线程的并发有序性，又保证了多线程的内存可见性。

可能 很多人都觉得莫名其妙，说JVM的内存模型，怎么会扯到cpu上去呢？在此，我认为很有必要阐述下，免得很多人看得不明不白的。先抛开java虚拟机不 谈，我们都知道，现在的计算机，cpu在计算的时候，并不总是从内存读取数据，它的数据读取顺序优先级是：寄存器－高速缓存－内存。线程耗费的是CPU， 线程计算的时候，原始的数据来自内存，在计算过程中，有些数据可能被频繁读取，这些数据被存储在寄存器和高速缓存中，当线程计算完后，这些缓存的数据在适 当的时候应该写回内存。当个多个线程同时读写某个内存数据时，就会产生多线程并发问题，涉及到三个特性：原子性，有序性，可见性。在《线程安全总结》这篇 文章中，为了理解方便，我把原子性和有序性统一叫做“多线程执行有序性”。支持多线程的平台都会面临这种问题，运行在多线程平台上支持多线程的语言应该提 供解决该问题的方案。

那么，我们看看JVM，JVM是一个虚拟的计算机，它也会面临多线程并发问题，java程序运行在java虚拟机平台上，java程序员不可能直接去控制 底层线程对寄存器高速缓存内存之间的同步，那么java从语法层面，应该给开发人员提供一种解决方案，这个方案就是诸如 synchronized, volatile,锁机制（如同步块，就绪队列，阻塞队列）等等。这些方案只是语法层面的，但我们要从本质上去理解它，不能仅仅知道一个 synchronized 可以保证同步就完了。   在这里我说的是jvm的内存模型，是动态的，面向多线程并发的，沿袭JSL的“working memory”的说法，只是不想牵扯到太多底层细节，因为《线程安全总结》这篇文章意在说明怎样从语法层面去理解java的线程同步，知道各个关键字的使用场景。

今天有人问我，那java的线程不是有栈吗？难道栈不是工作内存吗？工作内存这四个字得放到具体的场景中描述，方能体现它具体的意义，在描述JVM的线程 同步时，工作内存指的是寄存器和告诉缓存的抽象描述，具体请自行参阅JLS。上面讲的都是动态的内存模型，甚至已经超越了JVM的范围，那么JVM的内存 静态存储是怎么划分的？今天还有人问我，jvm的内存模型不是有eden区吗？也不见你提起。我跟他说，这是两个角度去看的，甚至是两个不同的范围，动态 的线程同步的内存模型，涵盖了cpu，寄存器，高速缓存，内存；JVM的静态内存储模型只是一种对内存的物理划分而已，它只局限在内存，而且只局限在 JVM的内存。那些什么线程栈，eden区都仅仅在JVM内存。

说说JVM的线程栈和有个朋友反复跟我纠结的eden区吧。JVM的内存，被划分了很多的区域：

1.程序计数器
每一个Java线程都有一个程序计数器来用于保存程序执行到当前方法的哪一个指令。
2.线程栈
线程的每个方法被执行的时候，都会同时创建一个帧（Frame）用于存储本地变量表、操作栈、动态链接、方法出入口等信息。每一个方法的调用至完成，就意
味着一个帧在VM栈中的入栈至出栈的过程。如果线程请求的栈深度大于虚拟机所允许的深度，将抛出StackOverflowError异常；如果VM栈可
以动态扩展（VM Spec中允许固定长度的VM栈），当扩展时无法申请到足够内存则抛出OutOfMemoryError异常。
3.本地方法栈
4.堆
每个线程的栈都是该线程私有的，堆则是所有线程共享的。当我们new一个对象时，该对象就被分配到了堆中。但是堆，并不是一个简单的概念，堆区又划分了很
多区域，为什么堆划分成这么多区域，这是为了JVM的内存垃圾收集，似乎越扯越远了，扯到垃圾收集了，现在的jvm的gc都是按代收集，堆区大致被分为三
大块：新生代，旧生代，持久代（虚拟的）；新生代又分为eden区，s0区，s1区。新建一个对象时，基本小的对象，生命周期短的对象都会放在新生代的
eden区中，eden区满时，有一个小范围的gc（minor gc），整个新生代满时，会有一个大范围的gc（major
gc），将新生代里的部分对象转到旧生代里。
5.方法区
其实就是永久代（Permanent Generation），方法区中存放了每个Class的结构信息，包括常量池、字段描述、方法描述等等。VM
Space描述中对这个区域的限制非常宽松，除了和Java堆一样不需要连续的内存，也可以选择固定大小或者可扩展外，甚至可以选择不实现垃圾收集。相对
来说，垃圾收集行为在这个区域是相对比较少发生的，但并不是某些描述那样永久代不会发生GC（至
少对当前主流的商业JVM实现来说是如此），这里的GC主要是对常量池的回收和对类的卸载，虽然回收的“成绩”一般也比较差强人意，尤其是类卸载，条件相
当苛刻。
6.常量池
 Class文件中除了有类的版本、字段、方法、接口等描述等信息外，还有一项信息是常量表(constant_pool
table)，用于存放编译期已可知的常量，这部分内容将在类加载后进入方法区（永久代）存放。但是Java语言并不要求常量一定只有编译期预置入
Class的常量表的内容才能进入方法区常量池，运行期间也可将新内容放入常量池（最典型的String.intern()方法）。

3.一个线程不安全的例子

　　当我们查看JDK API的时候，总会发现一些类说明写着，线程安全或者线程不安全，比如说StringBuilder中，有这么一句，“将StringBuilder 的实例用于多个线程是不安全的。如果需要这样的同步，则建议使用StringBuffer。 ”，那么下面手动创建一个线程不安全的类，然后在多线程中使用这个类，看看有什么效果。

Count.java：

 public class Count {
    private int num;
    public void count() {
        for(int i = 1; i <= 10; i++) {
            num += i;
        }
        System.out.println(Thread.currentThread().getName() + "-" + num);
    }
} 

　　在这个类中的count方法是计算1一直加到10的和，并输出当前线程名和总和，我们期望的是每个线程都会输出55。

ThreadTest.java：

 public class ThreadTest {
    public static void main(String[] args) {
        Runnable runnable = new Runnable() {
            Count count = new Count();
            public void run() {
                count.count();
            }
        };
        for(int i = 0; i < 10; i++) {
            new Thread(runnable).start();
        }
    }
} 

这里启动了10个线程，看一下输出结果：

 Thread-0-55
Thread-1-110
Thread-2-165
Thread-4-220
Thread-5-275
Thread-6-330
Thread-3-385
Thread-7-440
Thread-8-495
Thread-9-550

只有Thread-0线程输出的结果是我们期望的，而输出的是每次都累加的，这里累加的原因以后的博文会说明，那么要想得到我们期望的结果，有几种解决方案：

1. 将Count中num变成count方法的局部变量(局部变量不存在线程安全问题)

 public class Count {
    public void count() {
        int num = 0;
        for(int i = 1; i <= 10; i++) {
            num += i;
        }
        System.out.println(Thread.currentThread().getName() + "-" + num);
    }
}

2. 将线程类成员变量拿到run方法中，这时count引用是线程内的局部变量；

 public class ThreadTest4 {
    public static void main(String[] args) {
        Runnable runnable = new Runnable() {
            public void run() {
                Count count = new Count();
                count.count();
            }
        };
        for(int i = 0; i < 10; i++) {
            new Thread(runnable).start();
        }
    }
} 

3. 每次启动一个线程使用不同的线程类，不推荐。

　　上述测试，我们发现，存在成员变量的类用于多线程时是不安全的，不安全体现在这个成员变量可能发生非原子性的操作， 而变量定义在方法内也就是局部变量是线程安全的。想想在使用struts1时，不推荐创建成员变量，因为action是单例的，如果创建了成员变量，就会 存在线程不安全的隐患，而struts2是每一次请求都会创建一个action，就不用考虑线程安全的问题。所以，日常开发中，通常需要考虑成员变量或者 说全局变量在多线程环境下，是否会引发一些问题。