代码实现

package com.ljw.thread;

public class RunnableDemo {

public static void main(String[] args) {
// 测试
RunnableDemo R = new RunnableDemo();
RunnableThread R1 = R.new RunnableThread("thread1");
R1.start();

RunnableThread R2 = R.new RunnableThread("thread2");
R2.start();

}

class RunnableThread implements Runnable{
private String threadName;
private Thread t;

public RunnableThread(String name) {
// TODO Auto-generated constructor stub
threadName = name;
System.out.println("创建线程 "+threadName);
}

@Override
public void run() {
System.out.println("正在运行线程："+threadName);

try {
for(int i=10;i>0;i--) {
System.out.println("线程："+threadName+" 正在打印："+i);
Thread.sleep(50);
}
}catch(Exception e) {
e.printStackTrace();
}

System.out.println("线程："+threadName+" 正在退出......");
}

public void start() {
System.out.println("开始线程 "+threadName);
if(t == null) {
t = new Thread(this, threadName);
t.start();
}
}

}
}

Callable中call方法可以有返回值，而Runnable中的run方法没有返回值

package com.ljw.thread;

import java.util.concurrent.Callable;
import java.util.concurrent.FutureTask;

public class CallableThreadTest implements Callable<Integer> {
public static void main(String[] args)
{
CallableThreadTest ctt = new CallableThreadTest();
FutureTask<Integer> ft = new FutureTask<>(ctt);
for(int i = 0;i < 10;i++)
{
System.out.println(Thread.currentThread().getName()+" 的循环变量i的值"+i);
if(i%2==0)
{
new Thread(ft,"有返回值的线程").start();
}
}
try
{
System.out.println("子线程的返回值："+ft.get());
} catch (InterruptedException e)
{
e.printStackTrace();
} catch (Exception e)
{
e.printStackTrace();
}

}
@Override
public Integer call() throws Exception
{
int i = 0;
for(;i<10;i++)
{
System.out.println(Thread.currentThread().getName()+" "+i);
}
return i;
}
}

可以同时访问，因为是访问不同对象(x和y)的同步锁

不能同时访问，因为两个方法是静态的，相当于用Something.cSyncA()和Something.cSyncB()访问,是相同的对象

可以同时访问，因为访问不同对象

5. Volatile 关键字

5.1 Volatile原理

• Java语言提供了一种稍微同步机制，即volatile变量，用来确保将变量的更新操作通知其他线程
• 在访问volatile变量是不会执行加锁操作，因此也就不会重新执行线程阻塞，volatile变量是一种比synchronized关键字轻量级的同步机制
• 当一个变量被volatile修饰后，不但具有可见性，而且还禁止指令重排。volatile的读性能消耗与普通变量几乎相同，但是写操作就慢一些，因为它要保证本地代码中插入许多内存屏障指令来保证处理器不发生乱序执行

6. 线程等待和唤醒

6.1 常用方法

• 在Object.java中，定义了wait()，notify()和notifyAll()等接口
• wait()方法的作用是让当前线程进入阻塞状态，同时会释放当前对象所持有的锁
• notify()唤醒当前对象上的等待线程，notifyAll()则是唤醒所有的线程

6.2 实例

package com.ljw.thread;

public class WaitDemo {
public static void main(String[] args) {

class ThreadTest extends Thread{

@Override
public void run() {
synchronized (this) {
System.out.println("开始运行线程 "+Thread.currentThread().getName());
System.out.println("唤醒线程notify()");
notify();
}
}
}

ThreadTest thread1 = new ThreadTest();
thread1.start();

synchronized (thread1) {
try {
System.out.println("主线程进入阻塞，释放thread对象的同步锁，wait()");
thread1.wait(); // wait()是让当前线程进入阻塞状态，wait()是在主线程中执行，
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println("主线程继续进行");
}
}

7. 线程让步和休眠

7.1 线程让步

7.1.1 概述

• 在Java线程中，yield()方法的作用是让步，它能让当前线程由“运行状态”进入到“就绪状态”，可能让其它同级别的线程获得执行权，但不一定，可能它自己再次由“就绪状态”进入到“运行状态”

7.1.2 实例

package com.ljw.thread;

public class YieldTest {

public static void main(String[] args) {

class ThreadA extends Thread{
public ThreadA(String name){
super(name);
}

@Override
public synchronized void run() {

for(int i=0;i<5;i++){
System.out.println(" "+this.getName()+" "+i);

if(i%2 == 0){
Thread.yield();
}
}
}
}

ThreadA t1 = new ThreadA("t1");
ThreadA t2 = new ThreadA("t2");
t1.start();
t2.start();
}
}

运行结果(不唯一)：

t1 0
t2 0
t1 1
t1 2
t2 1
t1 3
t2 2
t1 4
t2 3
t2 4

结果说明： 线程t1在能被2整除的时候，并不一定切换到线程2。这表明，yield()方法虽然可以让线程由“运行状态”进入到“就绪状态”；但是，它不一定会让其他线程获取CPU执行权（其他线程进入到“运行状态”）。即时这个“其他线程”与当前调用yield()的线程具有相同的优先级。

7.1.3 yield()和wait()比较

• wait()的作用是让当前线程由“运行状态”进入“阻塞状态”，而yield()是让当前线程由“运行状态”进入“就绪状态”
• wait()是会让线程释放它所持有的对象的同步锁，而yield()方法不会释放对象的同步锁。

7.2 线程休眠

7.2.1 概述

• sleep()方法定义在Thread类中，sleep()的作用是让当前线程休眠，即当前线程会从“远程状态”进入到“休眠（阻塞）状态”
• sleep()会指定休眠时间，线程休眠的时间会大于/等于该休眠时间
• 在线程重新被唤醒时，它会由“阻塞状态”变成“就绪状态”，从而等待CPU的调度执行。

7.2.2 sleep() 和 wait()的比较

• wait()的作用是让当前的线程由“运行状态”进入到“等待（阻塞）状态”的同时，也会释放同步锁- 但是sleep()的作用是让当前线程由“运行状态”进入到“休眠（阻塞）”状态，但不会释放锁。

8. 加入一个线程

8.1 概述

• 在一个线程T上调用另一个线程t的 join() 方法，相当于在T中加入线程t，要等t结束后(即t.isAlive为假)， join() 后面的代码块才会执行。
• 可以在调用jion()时带上一个超时参数（单位可以是毫秒，或者纳秒），这样如果目标线程在这段时间到期时还没有结束的话，join()方法总能返回

9. 终止一个线程

9.1 概述

• interrupt()并不会终止处于“运行状态”的线程，它会将线程的中断标记设为true。
• 综合线程处于“阻塞状态”和“运行状态”的终止方式，比较通用的终止线程的形式如下：

@Override
public void run() {
try {
// 1. isInterrupted()保证，只要中断标记为true就终止线程。
while (!isInterrupted()) {
// 执行任务...
}
} catch (InterruptedException ie) {
// 2. InterruptedException异常保证，当InterruptedException异常产生时，线程被终止。
}
}

9.2 实例

public class InterruptBlock {

/**
* @param args
*/
public static void main(String[] args) {

class MyThread extends Thread{
public MyThread(String name){
super(name);
}

@Override
public void run() {
try {
int i=0;
while(!isInterrupted()){
Thread.sleep(100);
i++;
System.out.println(Thread.currentThread().getName()+ " ("+this.getState()+") loop "+i);
}
} catch (InterruptedException e) {
e.printStackTrace();
System.out.println(Thread.currentThread().getName()+ " ("+this.getState()+") catch InterruptedExecption");
}
}
}

try {

//新建
Thread t1 = new MyThread("t1");
System.out.println(t1.getName()+" ("+t1.getState()+" ) is new.");

System.out.println("luo1:"+t1.isInterrupted());
//启动
t1.start();
System.out.println(t1.getName()+" ("+t1.getState()+" ) is started.");
System.out.println("luo2:"+t1.isInterrupted());
//主线程休眠300ms，然后主线程给t1发“中断”指令
Thread.sleep(300);
t1.interrupt();
System.out.println("luo3:"+t1.isInterrupted());
System.out.println(t1.getName()+" ("+t1.getState()+" ) is interrupted.");

//主线程休眠300ms，然后查看t1的状态
Thread.sleep(300);
System.out.println(t1.getName()+" ("+t1.getState()+" ) is interrupted now .");

} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}

}

}

运行结果：

t1 (NEW ) is new.
luo1:false
t1 (RUNNABLE ) is started.
luo2:false
t1 (RUNNABLE) loop 1
t1 (RUNNABLE) loop 2
luo3:true
t1 (RUNNABLE) loop 3
t1 (RUNNABLE ) is interrupted.
t1 (TERMINATED ) is interrupted now .

9.3 interrupt()和isInterrupted()的区别

• interrupt()和isInterrupted()都能够用于检测对象的“中断标记”。区别是：interrupt()除了返回中断标记之外，它还会清除中断标记（即将中断标记设为false）；而isInterrupted()仅仅返回中断标记。

线程进阶

1. 线程池

• 示例

package com.ljw.thread;

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

public class ThreadPoolDemo {

public static void main(String[] args) { // 主线程
// 线程池 ---> Executors工具类（工厂类）
/*
* newFixedThreadPool(int threadCount) 创建固定数量的线程池
* newCachedThreadPool() 创建动态数量的线程池
*/
ExecutorService es = Executors.newFixedThreadPool(3);

Runnable task = new MyTask();

// 提交任务
es.submit(task);
es.submit(task);

es.shutdown(); // 关闭线程池，则表示不在接收新任务，不代表正在线程池的任务会停掉
}
}

class MyTask implements Runnable{

@Override
public void run() {
for(int i=0;i<100;i++) {
System.out.println(Thread.currentThread().getName()+" MyTask "+i);
}
}
}

2. 线程安全与锁

2.1 重入锁和读写锁

package com.ljw.thread;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.locks.ReentrantLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock.ReadLock;
import java.util.concurrent.locks.ReentrantReadWriteLock.WriteLock;

/**
* ReentrantLock类，重入锁：Lock接口的实现类，与synchronized一样具有互斥锁功能 lock() 和 unlock()
* ReentrantReadWriteLock类，读写锁：一种支持一写多读的同步锁，读写分离，分别分配读锁和写锁，在读操作远远高于写操作的环境中可以提高效率
* 		互斥规则：
* 			写--写：互斥，阻塞
* 			读--写：互斥，阻塞
* 			读--读：不互斥，不阻塞
*
*/

public class LockDemo {

public static void main(String[] args) {
ExecutorService es = Executors.newFixedThreadPool(20);
Student s = new Student();
//		ReentrantLock rLock = new ReentrantLock(); // 用ReenTrantLock加锁运行时间20008ms
ReentrantReadWriteLock rwLock = new ReentrantReadWriteLock(); // 用读写锁分别对读写任务加锁运行时间3003ms
ReadLock rl = rwLock.readLock();
WriteLock wl = rwLock.writeLock();

// 写任务
Callable<Object> writeTask = new Callable<Object>() {

@Override
public Object call() throws Exception {
//				rLock.lock();
wl.lock();
try {
Thread.sleep(1000);
s.setValue(100);
}finally {
//					rLock.unlock();
wl.unlock();
}

return null;
}};

// 读任务
Callable<Object> readTask = new Callable<Object>() {

@Override
public Object call() throws Exception {
//				rLock.lock();
rl.lock();
try {
Thread.sleep(1000);
s.getValue();
}finally {
//					rLock.unlock();
rl.unlock();
}
return null;
}};

// 开始时间
long start = System.currentTimeMillis();
for(int i=0;i<2;i++) { // 写任务执行 2 次
es.submit(writeTask);
}
for(int i=0;i<18;i++) { // 读任务执行 18 次
es.submit(readTask);
}

es.shutdown(); // 停止线程池，不在接受新的任务，将现有任务全部执行完毕

while(true) {
if(es.isTerminated()) { // 当线程池中所有任务执行完毕，返回true，否则返回false
break;
}
}

// 执行到这里，说明线程池中所有任务都执行完毕，可以计算结束时间
System.out.println(System.currentTimeMillis()-start);

}
}

class Student {
private int value;

//读
public int getValue() {
return value;
}

//写
public void setValue(int value) {
this.value = value;
}
}

2.2 线程安全

2.2.1 Collections工具类

• Collections工具类中提供了多个可以获得线程安全集合的方法

static <T> Collection<T> synchronizedCollection(Collection<T> c)
//返回由指定集合支持的同步（线程安全）集合。
static <T> List<T> synchronizedList(List<T> list)
//返回由指定列表支持的同步（线程安全）列表。
static <K,V> Map<K,V> synchronizedMap(Map<K,V> m)
//返回由指定地图支持的同步（线程安全）映射。
static <K,V> NavigableMap<K,V> synchronizedNavigableMap(NavigableMap<K,V> m)
//返回由指定的可导航地图支持的同步（线程安全）可导航地图。
static <T> NavigableSet<T> synchronizedNavigableSet(NavigableSet<T> s)
//返回由指定的可导航集支持的同步（线程安全）可导航集。
static <T> Set<T> synchronizedSet(Set<T> s)
//返回由指定集合支持的同步（线程安全）集。
static <K,V> SortedMap<K,V> synchronizedSortedMap(SortedMap<K,V> m)
//返回由指定的排序映射支持的同步（线程安全）排序映射。
static <T> SortedSet<T> synchronizedSortedSet(SortedSet<T> s)
//返回由指定的排序集支持的同步（线程安全）排序集。

2.2.2 CopyOnWriteArrayList

• 线程安全的ArrayList
• 读写分离，写加锁，读没锁，读写之间不互斥
• 使用方法与ArrayList无异

2.2.3 CopyOnWriteArraySet

• 基于 CopyOnWriteArrayList

2.2.4 ConcurrentHashMap

• 初始容量默认为16段（Segment），采用分段锁设计
• 不对整个Map加锁，只对每个Segment加锁
• 当多个对象访问同个Segment才会互斥