int a = 10; //語句1
int r = 2; //語句2
a = a + 3; //語句3
r = a*a;  //語句4

package chauncy.concurrentprogramming;

class ThreadVolatile extends Thread {
	public volatile boolean flag = true;

	@Override
	public void run() {
		System.out.println("子線程開始執(zhí)行...");
		while (flag) {

		}
		System.out.println("子線程結(jié)束執(zhí)行...");
	}

	public void isRun(boolean flag) {
		this.flag = flag;
	}
}

/**
 * @classDesc: 功能描述(Volatile關(guān)鍵字的使用)
 * @author: ChauncyWang
 * @createTime: 2019年3月12日 上午10:17:14
 * @version: 1.0
 */
public class Volatile {
	public static void main(String[] args) throws InterruptedException {
		ThreadVolatile threadVolatile1 = new ThreadVolatile();
		threadVolatile1.start();
		Thread.sleep(300);
		/**
		 * 如果不對變量加Volatile關(guān)鍵字，則子線程不會停止運行 原因：線程之間是不可見的，讀取的是副本，沒有及時讀取到主內(nèi)存結(jié)果。
		 * 解決辦法：使用Volatile關(guān)鍵字解決線程之間的可見性，強制線程每次讀取該值的時候都去“主內(nèi)存”中取值。
		 */
		threadVolatile1.isRun(false);
		System.out.println("flag:" + threadVolatile1.flag);
	}
}

package chauncy.concurrentprogramming;

import java.util.concurrent.atomic.AtomicInteger;

class VolatileNoAtomicThread extends Thread {
	// private static volatile int count = 0;
	private static AtomicInteger atomicInteger = new AtomicInteger(0);

	@Override
	public void run() {
		for (int i = 0; i < 1000; i++) {
			// count++;
			atomicInteger.incrementAndGet();// count++
		}
		System.out.println(getName() + "-----" + atomicInteger);
	}
}

/**
 * @classDesc: 功能描述(Volatile修飾不具有原子性(不具有同步性)，不能解決線程安全問題)
 * @author: ChauncyWang
 * @createTime: 2019年3月12日 上午10:39:30
 * @version: 1.0
 */
public class VolatileNoAtomic {
	public static void main(String[] args) {
		// 初始化10個線程
		VolatileNoAtomicThread[] volatileNoAtomicThread = new VolatileNoAtomicThread[10];
		for (int i = 0; i < volatileNoAtomicThread.length; i++) {
			// 創(chuàng)建每一個線程
			volatileNoAtomicThread[i] = new VolatileNoAtomicThread();
		}
		for (int i = 0; i < volatileNoAtomicThread.length; i++) {
			// 啟動每一個線程
			volatileNoAtomicThread[i].start();
		}
	}
}

package chauncy.concurrentprogramming;

class Res {
	// private int count=0;
	/*
	 * 設(shè)置本地局部變量，和其他線程局部變量隔離開，互不影響
	 */
	private ThreadLocal<Integer> count = new ThreadLocal<Integer>() {
		protected Integer initialValue() {
			// 設(shè)置當(dāng)前線程局部變量的初始化值
			return 0;
		};
	};

	/**
	 * 
	 * @methodDesc: 功能描述(生成訂單號)
	 * @author: ChauncyWang
	 * @param: @return
	 * @createTime: 2019年3月12日 下午2:23:57
	 * @returnType: int
	 */
	public Integer getNum() {
		int count = this.count.get() + 1;
		this.count.set(count);
		return count;
	}
}

class ThreadLocalDemo extends Thread {
	private Res res;

	public ThreadLocalDemo(Res res) {
		this.res = res;
	}

	@Override
	public void run() {
		for (int i = 0; i < 3; i++) {
			try {
				Thread.sleep(30);
			} catch (Exception e) {
			}
			System.out.println(getName() + "----i:" + i + ",number:" + res.getNum());
		}
	}
}

/**
 * @classDesc: 功能描述(本地線程的使用：創(chuàng)建三個線程，每個線程生成自己獨立的序列號)
 * @author: ChauncyWang
 * @createTime: 2019年3月12日 下午2:21:03
 * @version: 1.0
 */
public class ThreadLocalTest {
	public static void main(String[] args) {
		Res res = new Res();
		ThreadLocalDemo t1 = new ThreadLocalDemo(res);
		ThreadLocalDemo t2 = new ThreadLocalDemo(res);
		ThreadLocalDemo t3 = new ThreadLocalDemo(res);
		t1.start();
		t2.start();
		t3.start();
	}
}

package chauncy.concurrentprogramming.executors;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class NewCachedThreadPool {
	public static void main(String[] args) {
		// 創(chuàng)建可緩存線程池
		ExecutorService newCachedThreadPool = Executors.newCachedThreadPool();
		// 執(zhí)行execute方法表示創(chuàng)建了一個線程，類似于start
		for (int i = 0; i < 30; i++) {
			int index = i;
			// index++;
			newCachedThreadPool.execute(new Runnable() {

				@Override
				public void run() {
					try {
						Thread.sleep(300);
					} catch (InterruptedException e) {
					}
					// 內(nèi)部類中使用的i必須是final,但是換成index后就不報錯，因為jdk1.8進行了優(yōu)化，能識別index是否被改變，如果把int
					// index=i;下邊的index++放開就會報錯。
					System.out.println(Thread.currentThread().getName() + "----" + index);
				}
			});
		}
		// 關(guān)閉線程池
		newCachedThreadPool.shutdown();
	}
}

package chauncy.concurrentprogramming.executors;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class NewFixedThreadPool {
	public static void main(String[] args) {
		// newFixedThreadPool 每次最多只能執(zhí)行三個，其他線程等待執(zhí)行。
		ExecutorService newFixedThreadPool = Executors.newFixedThreadPool(3);
		for (int i = 0; i < 10; i++) {
			int index = i;
			newFixedThreadPool.execute(new Runnable() {
				public void run() {
					try {
						Thread.sleep(1000);
					} catch (InterruptedException e) {
					}
					System.out.println(Thread.currentThread().getName() + "----i:" + index);
				}
			});
		}
	}
}

package chauncy.concurrentprogramming.executors;

import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

public class NewScheduledThreadPool {
	public static void main(String[] args) {
		// 入?yún)榫€程池大小，
		ScheduledExecutorService newScheduledThreadPool = Executors.newScheduledThreadPool(5);
		// schedule執(zhí)行定時任務(wù)線程池,第一個參數(shù)需要創(chuàng)建Runnable接口對象，第二、三個參數(shù)表示多少個單位時間執(zhí)行run方法。
		newScheduledThreadPool.schedule(new Runnable() {
			public void run() {
				System.out.println("我是三秒鐘之后執(zhí)行。。。。");
			}
		}, 3, TimeUnit.SECONDS);
	}
}

package chauncy.concurrentprogramming.executors;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class NewSingleThreadExecutor {
	public static void main(String[] args) {
		ExecutorService newSingleThreadExecutor = Executors.newSingleThreadExecutor();
		for (int i = 0; i < 10; i++) {
			int index = i;
			newSingleThreadExecutor.execute(new Runnable() {
				public void run() {
					System.out.println(Thread.currentThread().getName() + "----i:" + index);
				}
			});
		}
	}
}