1.java线程特性
1.原子性：即一个操做或者多个操做 要么所有执行而且执行的过程不会被任何因素打断，要么就都不执行 银行转帐，本身转100给别人，本身帐户少100 别人多100java
不会出现，本身少了100 别人那里却也没有多100的状况安全
2.有序性：程序执行的顺序按照代码的前后顺序执行。通常来讲处理器为了提升程序运行效率，可能会对输入代码进行优化，它不保证程序中各个语句的执行前后顺序同代码中的顺序一致，可是它会保证程序最终执行结果和代码顺序执行的结果是一致的并发
3.可见性：多个线程共同访问同一个变量的时候，一个线程修改了该变量的值,其余线程应该能看见这个变量的修改jvm
2.java内存模型
java内存模型也叫共享内存模型(JMM) java内存模型决定了 多个线程共享同个变量的时候，某个线程修改了共享变量，这个修改应该被其余线程看见。ide
例如 static int a=3 当多个线程共享该变量的时候，a=3 是放在主内存中，每一个线程都有本身私有本地内存，私有本地内存存放的是共享内存变量的副本优化
线程A,B 操做主内存共享变量的时候，会先将主内存的变量复制一份到线程A,B本身的本地内存中，保存一个副本。若是要想保证线程的可见性，A 线程本地内存的副本修改之后，须要刷新到主内存之中，而后线程B在从新去主内存中刷新线程A更新之后的值。this
当前主内存的值为0(共享变量 int a=0) 若是有两个线程 A ,B 操做主内存的值，A,B线程会先将主内存的值 复制一份到本身的本地内存中，若是A线程修改变量atom
a的值为1，修改的是A线程本身本地内存中的值，此时线程B 和主内存中的值仍是0，当线程A,B 通讯的时候，A线程就将本地内存中a变量的值刷新到主内存中，而后B线程spa
须要操做变量a的时候，会先到主内存中获取最新的值，在复制到本身的本地内存中线程
3.Volatile保证变量的可见性
package com.thread; class ThreadVolatileDemo extends Thread { public boolean flag = true; @Override public void run() { System.out.println("开始执行子线程...."); while (flag) { } System.out.println("线程中止"); } public void setRuning(boolean flag) { this.flag = flag; } } public class VolatileDemo { public static void main(String[] args) throws InterruptedException { ThreadVolatileDemo threadVolatileDemo = new ThreadVolatileDemo(); threadVolatileDemo.start(); Thread.sleep(3000); threadVolatileDemo.setRuning(false); System.out.println("理想情况下设置false之后线程会中止运行"); Thread.sleep(1000); System.out.println(threadVolatileDemo.flag); } }
输出结果：
开始执行子线程.... 理想情况下设置false之后线程会中止运行 false
（一直执行while循环，已经将flag设置成了false 可是程序一直没有中止，是由于 该线程一直读取的是副本，并无去刷新主内存中的值）
Volatile关键字将解决线程之间可见性, 强制线程每次读取该值的时候都去“主内存”中取值
用法：public boolean volatile flag；
每一个线程操做flag的时候,都会去主内存刷新最新的flag值
4.Volatile是否能保证线程的安全性(原子性)
package com.thread; public class VolatileSyn extends Thread { public static volatile int count = 0; public void run() { for (int i = 0; i < 1000; i++) { count++; } } public static void main(String[] args) throws InterruptedException { VolatileSyn[] volatileSyns = new VolatileSyn[4]; for (int i = 0; i < volatileSyns.length; i++) { volatileSyns[i] = new VolatileSyn(); } for (VolatileSyn volatileSyn : volatileSyns) { volatileSyn.start(); } Thread.sleep(4000); System.out.println(VolatileSyn.count); } }
建立4条线程或者10条线程，共享可见变量count，每一个线程都执行+1000的操做，理论值应该是4000，可是屡次执行的结果 ，count++是线程不安全
最后的值 不等于4000(也有等于4000的) 屡次操做结果不一样 因而可知volatile并不能保证线程的安全问题。volatile能保证线程的可见性，例如：A 线程刚从主内存刷新过来count值 正准备操做的时候，B线程 修改了count的值 此时A 的值就不是最新的了
5.AtomicInteger原子类
AtomicInteger是一个提供原子操做的Integer类，经过线程安全的方式操做加减。
package com.thread; import java.util.concurrent.atomic.AtomicInteger; public class VolatileNoAtomic extends Thread { private static AtomicInteger count = new AtomicInteger(0); @Override public void run() { for (int i = 0; i < 1000; i++) { //等同于i++ count.incrementAndGet(); //decrementAndGet } } public static void main(String[] args) throws InterruptedException { // 初始化10个线程 VolatileNoAtomic[] volatileNoAtomic = new VolatileNoAtomic[10]; for (int i = 0; i < 10; i++) { // 建立 volatileNoAtomic[i] = new VolatileNoAtomic(); } for (int i = 0; i < volatileNoAtomic.length; i++) { volatileNoAtomic[i].start(); } Thread.sleep(4000); System.out.println(VolatileNoAtomic.count); } }
6.volatile与synchronized区别
仅靠volatile不能保证线程的安全性。（原子性）
①volatile轻量级，只能修饰变量。synchronized重量级，还可修饰方法
②volatile只能保证数据的可见性，不能用来同步，由于多个线程并发访问volatile修饰的变量不会阻塞。
synchronized不只保证可见性，并且还保证原子性，由于，只有得到了锁的线程才能进入临界区，从而保证临界区中的全部语句都所有执行。多个线程争抢synchronized锁对象时，会出现阻塞。
线程安全性
线程安全性包括两个方面，①可见性。②原子性。
从上面自增的例子中能够看出：仅仅使用volatile并不能保证线程安全性。而synchronized则可实现线程的安全性。
7.wait()、notify、notifyAll()方法
wait()、notify()、notifyAll()是三个定义在Object类里的方法，能够用来控制线程的状态。
这三个方法最终调用的都是jvm级的native方法。随着jvm运行平台的不一样可能有些许差别。
若是对象调用了wait方法就会使持有该对象的线程把该对象的控制权交出去，而后处于等待状态。
若是对象调用了notify方法就会通知某个正在等待这个对象的控制权的线程能够继续运行。
若是对象调用了notifyAll方法就会通知全部等待这个对象控制权的线程继续运行。
注意:必定要在线程同步中使用,而且是同一个锁的资源
8.wait和sleep的区别
1.wait是obejct方法，sleep是Thread方法
2.wait方法调用之后，须要手动唤醒，Sleep休眠 休眠时间到了之后，不须要任何操做能继续向下执行（监控状态依然保持）
3.wait方法放弃当前线程持有的锁，sleep只是放弃当前cpu的持有，但当前线程仍是持有对象锁