Volatile 变量的声明
11/21/2016 7:21:53 PM From 《高并发程序设计》
volatile 保证一个线程修改变量之后，另一个线程能看到这个改动。
声明一个volatile变量相当于告诉虚拟机，这个变量的值极有可能被修改，为了确保该变量能被应用程序的所有线程访问看到，需要用volatile去声明，在本人所学的Linux C中，定义的volatile变量意味着不对这个变量去进行编译优化，即每次都是从内存中读取该数据，而不是从被优化存储到cache或者寄存器中读取。我想意思大概是相近的吧，也许就是一个意思呢，不知道。
/**
* Created by loveqh on 2016/11/19.
*/
public class JoinMain {
public volatile static int i = 0;
public static void main(String[] args) throws InterruptedException {
Thread t = new Thread(new Runnable() {
@Override
public void run() {
for (i = 0; i < 100000; i++) ;
}
});
t.start();
t.join();
System.out.println(i);
}
}
输出为
10000
虽然volatile对于原子性起了很大的帮助，但是，但是，volatile不能代替锁，无法保证一些复合操作的原子性，如 i++ 如下 因为2个线程同时写入i时，一个线程的结果会覆盖另外一个线程的结果。
package ParallelBasic;
/**
* 文件描述：
* 作者： bamboo
* 时间： 2016/11/21
*/
public class MultiThreadLong {
public volatile static long i = 0; //volatile 不能代替锁
public static class PlusTask implements Runnable {
@Override
public void run() {
for (int k = 0; k < 100000; k++) {
i++;
}
}
}
public static void main(String[] args) throws InterruptedException {
Thread[] threads = new Thread[10];
for (int i = 0; i < 10; i++) {
threads[i] = new Thread(new PlusTask());
threads[i].start();
}
for (int i = 0; i < 10; i++) {
threads[i].join();
}
System.out.println(i);
}
}
输出935458。因为2个线程同时写入i时，一个线程的结果会覆盖另外一个线程的结果。
来看另一个的例子：
package ParallelBasic;
/**
* 文件描述：
* 作者： bamboo
* 时间： 2016/11/21
*/
public class MultiThreadLong {
private static boolean ready;
private static int number;
private static class ReaderThread implements Runnable {
@Override
public void run() {
while (!ready) ;
System.out.println(number);
}
}
public static void main(String[] args) throws InterruptedException {
Thread t1 = new Thread(new ReaderThread());
t1.start();
Thread.sleep(1000);
number = 42;
ready = true;
Thread.sleep(1000);
}
}
如果就这样执行，那么该程序永远不会停止，原因是在Server模式下（常用的普通模式 通过java -version可查看） 系统对代码进行了优化（具体就是发现ready变量一直使用，将其放在cache或者寄存器中）所有ready永远不会为false。正确的做法是在ready定义处添加volatile修饰。
在此处提到Server模式。顺便说一下:
虚拟机的Server模式，启动较慢（10%），但是一旦运行性能提升明显，适合做服务器。
虚拟机的Client模式，适合GUI界面的交互应用。
JVM在client模式默认-Xms是1M，-Xmx是64M；JVM在Server模式默认-Xms是128M，-Xmx是1024M
-Xms指的是初始堆大小 -Xmx指的是最大堆大小.
ThreadGroup 线程组
线程组就是将相同职能的线程放在一个组里，利于分类和管理。
package ParallelBasic;
/**
* 文件描述：
* 作者： bamboo
* 时间： 2016/11/21
*/
public class ThreadGroup implements Runnable {
@Override
public void run() {
String groupAndName = Thread.currentThread().getThreadGroup().getName() +
"_" + Thread.currentThread().getName();
while (true) {
System.out.println("I am" + groupAndName);
try {
Thread.sleep(3000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
public static void main(String[] args) {
ThreadGroup tg = new ThreadGroup("PrintGroup");
Thread t1 = new Thread(tg, new ThreadGroupName(), "T1");//"T1" the name of the new thread
Thread t2 = new Thread(tg, new ThreadGroupName(), "T2");
t1.start();
t2.start();
System.out.println(tg.activeCount());//tg.activeCount() 由于线程的动态的，所以这个值是估计值
tg.list();//打印线程组
}
}
输出
2
I am PrintGroup_T1
java.lang.ThreadGroup[name=PrintGroup,maxpri=10]
Thread[T1,5,PrintGroup]
Thread[T2,5,PrintGroup]
I am PrintGroup_T2
I am PrintGroup_T2
I am PrintGroup_T1
I am PrintGroup_T1
I am PrintGroup_T2 ....
值得注意的是：tg.stop()方法， 会停止所有线程组中的线程,很暴力 和Thread.sleep()方法一样，所以现在被废弃了。
Daemon 守护线程
守护线程是系统的守护者，运行在后台的线程。当用户线程全部结束时，守护线程无事可做自然退出。
package ParallelBasic;
/**
* 文件描述：守护线程如垃圾回收线程 JIT线程
* 当用户线程结束时，只有守护线程时，无事可做，就会自然退出
* 作者： bamboo
* 时间： 2016/11/21
*/
public class Daemon {
public static void main(String[] args) throws InterruptedException {
Thread t1 = new Thread(new Runnable() {
@Override
public void run() {
System.out.println("I am alive");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});
t1.setDaemon(true);
t1.start();
Thread.sleep(3000);
}
}
值得注意的是
t1.setDaemon(true);
t1.start();
应该先设置守护线程，再start,如果设置错了，会抛出设置守护线程错误异常，但是程序依然运行下去，原因是被当做用户线程继续执行了。当主线程结束时，守护线程也消失了。
Priority 线程优先级
java中线程优先级1-10 10为最高 和Linux值相反，linux优先级1最大
- MIN_PRIORITY=1;
- MAX_PRIORITY=10;
- NORM_PRIORITY=5;
`
package ParallelBasic;
/**
* 文件描述：
* java中线程优先级1-10 10为最高 和Linux值相反，linux优先级1最大
* MIN_PRIORITY=1;
* MAX_PRIORITY=10;
* NORM_PRIORITY=5;
* 作者： bamboo
* 时间： 2016/11/21
*/
public class ThreadPriority {
public static class HighPriority implements Runnable {
static int count = 0;
@Override
public void run() {
while (true) {
synchronized (ThreadPriority.class) {
count++;
if (count > 100000000) {
System.out.println("HighPriority is complete");
break;
}
}
}
}
}
public static class LowPriority implements Runnable {
static int count = 0;
@Override
public void run() {
while (true) {
//synchronized (ThreadPriority.class) 产生一次资源竞争，让效果更明显
synchronized (ThreadPriority.class) {
count++;
if (count > 100000000) {
System.out.println("LowPriority is complete");
break;
}
}
}
}
}
public static void main(String[] args) {
Thread h = new Thread(new HighPriority());
Thread l = new Thread(new LowPriority());
h.setPriority(Thread.MAX_PRIORITY);
l.setPriority(Thread.MIN_PRIORITY);
l.start();
h.start();
}
}
输出的结果是
HighPriority is complete
LowPriority is complete
Process finished with exit code 0
虽然体现出的结果是这样，但是高优先级只是在大部分情况下会优先于低优先级线程执行，不一定每次都是这样。使用了synchronized (ThreadPriority.class) 产生一次资源竞争，让效果更明显。
synchronized 同步关键字
实现线程间的同步，工作就是对同步代码加锁。
一次只能有一个线程进入到代码块中，从而保证线程的安全性。即当线程A写入的时候，线程B不仅不能写，还不能读（因为进入不到代码块中）。
synchronized的多种用法
- 指定加锁对象：对给定对象加锁，进入同步代码块前要获得给定对象的锁。
- 直接作用于实例方法：相当于对当前实例加锁，进入同步代码前要获取当前实例的锁。
- 直接作用于静态方法：相当于对当前类加锁，进入同步代码前要获取当前类的锁。
下列代码用来解决volatile复合操作原子性问题的。
package ParallelBasic;
/**
* 文件描述：
* 作者： bamboo
* 时间： 2016/11/21
*/
public class Synchronized {
public static long i = 0; //volatile 不能代替锁
static PlusTask plusTask= new PlusTask();
public static class PlusTask implements Runnable {
@Override
public void run() {
for (int k = 0; k < 10000; k++) {
increase（）；
}
}
synchronized void increase() {
i++;
}
public static void main(String[] args) throws InterruptedException {
Thread[] threads = new Thread[10];
for (int i = 0; i < 10; i++) {
threads[i] = new Thread(new PlusTask());
threads[i].start();
}
for (int i = 0; i < 10; i++) {
threads[i].join();
}
System.out.println(i);
}
}
}
结果却输出了
95262
注意到上述使用synchronized的方法，分析上述代码得知，synchronized void increase(){}
是直接作用于实例方法的，而在main函数中，new了非常10个实例，说明加锁都加到了不同的对象上，这样就会造成， 2个线程同时写入i时，一个线程的结果会覆盖另外一个线程的结果。
正确的做法是有
在main函数中，使用同一个对象创建线程。
将increase方法提升为static类方法，这样每次都锁定类。
- 如果i不是数据类型，而是一个对象的话，那么可以直接
synchronized（Object instance）此处不受用。
并行程序中隐藏的Bug 虽然小，但是容易致命
溢出
并发下的ArrayList
并发下的HashMap
加锁对象的错误
溢出，无法提示的错误
/**
* 文件描述：
* 作者： bamboo
* 时间： 2016/11/21
*/
public class OutIndex {
public static void main(String[] args) {
int a =1023454656;
int b =1232234234;
System.out.println(a+b);
}
}
out:
-2039278406
Process finished with exit code 0
如果是单单这样的一个程序当然会想到，是溢出的问题，如果是在很复杂的环境中，出现了这样的错误，那种调不出来的bug，真是令人难受。
并发下的ArrayList
并发下的ArrayList,非线程安全。
package ParallelBasic;
import java.util.ArrayList;
import java.util.Vector;
/**
* 文件描述：线程不安全容器,多线程下容易出错
* 作者： bamboo
* 时间： 2016/11/21
*/
public class ArrayListMultiThread {
static ArrayList<Integer> al = new ArrayList<Integer>(10);
// static Vector<Integer> al = new Vector<>(10);
public static class AddThread implements Runnable {
@Override
public void run() {
for (int i = 0; i < 100000; i++) {
al.add(i);
}
}
}
public static void main(String[] args) throws InterruptedException {
Thread t1 = new Thread(new AddThread());
Thread t2 = new Thread(new AddThread());
t1.start();t2.start();
t1.join();
t2.join();
System.out.println(al.size());
}
}
输出为
Exception in thread "Thread-0" java.lang.ArrayIndexOutOfBoundsException: 549
at java.util.ArrayList.add(ArrayList.java:441)
at ParallelBasic.ArrayListMultiThread$AddThread.run(ArrayListMultiThread.java:28)
at java.lang.Thread.run(Thread.java:744)
或者：
100430
原因是ArrayList在扩容过程中，内部的一致性被破坏，但由于没有锁保护，另一个线程访问到了不一致的内部状态，导致越界。
也可能直接打印一个小于如178233 这样的 值，但是不会报错，两个线程访问了同一位置导致覆盖。
解决办法用vector代替ArrayList
static Vector<Integer> al = new Vector<>(10);
并发下的HashMap
并发下的HashMap,非线程安全。
下列代码有毒
package ParallelBasic;
import java.util.HashMap;
import java.util.Map;
/**
* 文件描述：并发下的hashMap也不是线程安全的
* 出现死循环，用ConcurrentHashMap
* 作者： bamboo
* 时间： 2016/11/21
*/
public class HashMapMultiThread {
static Map<String, String> map = new HashMap<>();
public static class AddThread implements Runnable {
int start = 0;
public AddThread(int start) {
this.start = start;
}
@Override
public void run() {
for (int i = start; i < 100000; i += 2) {
map.put(Integer.toString(i), Integer.toBinaryString(i));
}
}
public static void main(String[] args) throws InterruptedException {
Thread t1 = new Thread(new AddThread(0));
Thread t2 = new Thread(new AddThread(1));
t1.start();t2.start();
t1.join();
t2.join();
System.out.println(map.size());
}
}
}
当我运行代码的时候，机子卡主了，吓得我赶紧退出程序，然后将循环数值改小一点，发现CPU占用率高的飞起，马上就99%了。然后再改小一点，发现ok了。
于是我使用jps命令查看线程运行状态。
C:\Users\bamboo>jps
8816 Launcher
8232 AppMain
7684 Jps
7936
C:\Users\bamboo>jstack 8232
....
"Thread-1" prio=6 tid=0x000000000a0bf000 nid=0x1a80 runnable [0x000000000a8ae000]
java.lang.Thread.State: RUNNABLE
at java.util.HashMap.put(HashMap.java:498)
at ParallelBasic.HashMapMultiThread$AddThread.run(HashMapMultiThread.java:25)
at java.lang.Thread.run(Thread.java:744)
"Thread-0" prio=6 tid=0x000000000a0be800 nid=0x249c runnable [0x000000000ab4e000]
java.lang.Thread.State: RUNNABLE
at java.util.HashMap.put(HashMap.java:498)
at ParallelBasic.HashMapMultiThread$AddThread.run(HashMapMultiThread.java:25)
at java.lang.Thread.run(Thread.java:744)
...
"main" prio=6 tid=0x000000000246f000 nid=0x63c in Object.wait() [0x000000000267e000]
java.lang.Thread.State: WAITING (on object monitor)
at java.lang.Object.wait(Native Method)
- waiting on <0x00000000eb151580> (a java.lang.Thread)
at java.lang.Thread.join(Thread.java:1280)
- locked <0x00000000eb151580> (a java.lang.Thread)
at java.lang.Thread.join(Thread.java:1354)
at ParallelBasic.HashMapMultiThread$AddThread.main(HashMapMultiThread.java:33)
at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:57)
at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
at java.lang.reflect.Method.invoke(Method.java:606)
at com.intellij.rt.execution.application.AppMain.main(AppMain.java:144)
....
注意到HaspMap.put函数的498行似乎发生了什么，于是我就跑去看了，下列第一行就为498行。
for (Entry<K,V> e = table[i]; e != null; e = e.next) {
Object k;
if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
V oldValue = e.value;
e.value = value;
e.recordAccess(this);
return oldValue;
}
}
看起来就是如同链表遍历一样，一个一个往下，但是由于在多线程环境下，可能发生冲突，链表结构被破坏，形成一个环，这样下去上述的迭代过程是一个死循环。 最简单的就是key1和key2 相互指向对方。
在JDK1.8已经做了大改动，很大程度上解决这个问题，但是还是有问题，最好的方法就是使用ConcurrentHashMap
加锁对象的错误
下列就是一个加锁加错对象的例子
package ParallelBasic;
public class LockInteger implements Runnable {
public static Integer i = 0;
static BadLockOnInteger instance = new BadLockOnInteger();
@Override
public void run() {
for (int j = 0; j < 1000000; j++) {
synchronized (i) {
i++; //对于此处，就是新建一个Integer对象，并将它的引用赋值给i；
}
}
}
public static void main(String[] args) throws InterruptedException {
Thread t1= new Thread(instance);
Thread t2= new Thread(instance);
t1.start();
t2.start();
t1.join();
t2.join();
System.out.println(i);
}
}
输出:
1883900
Process finished with exit code 0
为什么呢，讲道理，该加锁的加锁了。问题出现在这个Integer上。Integer这个类的对象是不可变对象。对其进行i++时，就是新建一个Integer对象，并将它的引用赋值给i，意思就是可能将锁加到了不同的Integer对象上，导致了2个线程同时写入i时，一个线程的结果会覆盖另外一个线程的结果。证明一下：
- 将经过编译的class文件使用javap反编译一下，并找到run方法
C:\Users\bamboo\Desktop\单源\Leetcode\out\ParallelBasic>javap -c -public BadLockOnInteger.class
Compiled from "BadLockOnInteger.java"
public class ParallelBasic.BadLockOnInteger implements java.lang.Runnable {
public static java.lang.Integer i;
public ParallelBasic.BadLockOnInteger();
.....
public void run();
Code:
0: iconst_0
1: istore_1
2: iload_1
3: ldc #2 // int 1000000
5: if_icmpge 55
8: getstatic #3 // Field i:Ljava/lang/Integer;
11: dup
12: astore_2
13: monitorenter
14: getstatic #3 // Field i:Ljava/lang/Integer;
17: astore_3
18: getstatic #3 // Field i:Ljava/lang/Integer;
21: invokevirtual #4 // Method java/lang/Integer.intValue:()I
24: iconst_1
25: iadd
26: invokestatic #5 // Method java/lang/Integer.valueOf:(I)Ljava/lang/Integer;
29: dup
30: putstatic #3 // Field i:Ljava/lang/Integer;
33: astore 4
35: aload_3
36: pop
37: aload_2
38: monitorexit
39: goto 49
42: astore 5
44: aload_2
45: monitorexit
46: aload 5
48: athrow
49: iinc 1, 1
52: goto 2
55: return
Exception table:
from to target type
14 39 42 any
42 46 42 any
...
}
第26行出现了感兴趣的东西，于是就去找到了Integer.valueOf(Int i)方法：
public static Integer valueOf(int i) {
assert IntegerCache.high >= 127;
if (i >= IntegerCache.low && i <= IntegerCache.high)
return IntegerCache.cache[i + (-IntegerCache.low)];
return new Integer(i);
}
果然，不可变对象原来是这样的。又学到了，这让我想到了另一个String和StringBuffer的区别，大体上也是这样的吧。很关键。
上述代码的修改方法就是将
synchronized (i);
改为
synchronized (instance);