1 进程

	1 进程和线程之间的关系：进程是线程的容器。

2 线程

---

1 线程的执行流程：

• **线程调用start(）**方法时，表示线程开始执行；
• 当线程执行时，处于RUNNABLE状态，表示线程所需的一切资源都准备好了；
• 当线程遇到synchronized同步块，就进入BLOCED阻塞状态，这时线程会暂停执行，直到获得请求的锁。

2 WAITING 和 TIMED_WAITING:

• WAITING 和 TIMED_WAITING都表示等待状态，区别是WAITING会进入一个无时间限制的等待，TIMED_WAITING会进行一个有限的等待。
• WAITING 的线程是在等待一些特殊事件：比如，wait(）方法等待notify（）方法，join等待目标线程的终止。
• 线程的基本操作
  1 注意：不要用run（）开启新线程，它只会在当前线程中，串行执行run（）中的代码。
  2 创建线程的两种方式：实现Runnable接口；继承Thread类；

  //Runnable接口public interface Runable{public abstract void run();
｝

4 终止线程：

• 为何终止：一般线程会自动终止，但是一些服务端的后台线程会常驻系统，它们本身是无穷循环，用于提供某些服务。
  1 使用stop()？ //未来将被废弃；
  stop（）有一个局限性： 当写入两个相同的值，当线程写到一半，并强行终止，对象就会被写坏。从而出现
  写读不一致的现象。stop发生的问题很难排查！，除非你很清楚你在干什么，否则不要随便使用stop（）去
  终止一个线程
  2 自行决定何时退出
  1 在自己的线程类中增加一个stopMe（）方法：

ChangeObjectThread extends Thread｛volatile Boolean stopme = false；public void stopMe（）｛stopme = true；｝public void run（）｛while（true）｛if（stopme）｛//退出位置pringtln（“exit by stop me！”）;break；｝//你的代码｝｝
｝

5 线程中断

• 什么是线程中断：
  线程中断不会使线程立即退出，而是给线程一个通知，告知目标线程，有人希望你退出了！至于**目标线程接到通知后
  如何处理，由自己决定。**这点很重要，避免了stop（）那样出现的问题。
• 与线程中断的三种方法：
  1 Thread.interrupt（）：通知目标线程中断，设置中断标志。
  2 Thread.isInterrupted（）：检查中断标志，判断当前线程是否被中断。
  3 Thread.interrupted（）：判断当前线程中断状态，但同时会清楚当前线程中断标志位状态。
  3 如何操作：

main（String[] args）｛Thread t1 = new Thread（）｛public void run（）｛while（true）｛//中断处理程序if（Thread.currentThread（）.isInterrupted（））｛sysou("Interrupted！")；break；｝...;Thread.yield（）；//线程让步｝	｝｝t1.start（）；Thread.sleep（2000）；t1.interrupt（）；//单单这里中断是没有效果的，一定要写入上面的中断处理程序
｝

• 中断的方法比stopme（）标记手法功能更强劲
• 强劲之处：在循环体中，出现wait（）或sleep（），只能通过中断识别。
  Thread.sleep（）方法会抛出一个InterruptedException中断异常，当线程sleep（）处于休眠时，如果被中断，异常就会产生。这时会清除中断标记位，如果不处理，在下次循环中无法捕获到这个中断，故在异常处理中，再次设置中断标记位

6 等待（wait）和通知（notify）

• 等待（wait）
  当线程A中，调用了obj.wait（），线程A停止继续执行，进入现场等待池中等待，让出系统资源，既让出了锁资源。线程A会一直等到其他线程调用obj.notify（）位置。obj对象成为多个线程的有效通信手段。
• wait 和 notify 如何工作？
  当一个线程调用obj.wait（），那么它就进入obj的等待队列。这个等待队列可能有多个线程。当obj.notify（）被调用时，它会从等待队列中水机选选择一个线程，将其唤醒（这里的唤醒是允许其去获得锁）。这个选择时随机的。
• 除了notify可以唤醒线程，还有notifyAll，只是notifyAll唤醒所有的线程，而不是一个。
• 注意点
  object.wait（）不是随便调用的，必须包含在对应同步语句中，无论是wait 还是 notify都需要首先获得目标对象
  （obj）的一个监视器。

public class SimpleWN{public static void main(String[] args) {Thread t1 = new T1();Thread t2 = new T2();t1.start();t2.start();}final static Object obj = new Object();public static class T1 extends Thread{@Overridepublic void run() {synchronized (obj) {System.out.println(System.currentTimeMillis() + ":T1 start! ");try {System.out.println(System.currentTimeMillis() + ":T1 wait for obj");obj.wait();} catch (InterruptedException e) {e.printStackTrace();}System.out.println(System.currentTimeMillis() + ":T1 end!");}super.run();}}public static class T2 extends Thread{@Overridepublic void run() {// TODO Auto-generated method stubsynchronized (obj) {System.out.println(System.currentTimeMillis() + ":T2 start! notify one thread!");obj.notify();System.out.println(System.currentTimeMillis() + ":T2 end!");try {Thread.sleep(2000);} catch (InterruptedException e) {// TODO Auto-generated catch blocke.printStackTrace();}}super.run();}}
}

• wait 和 sleep :都是等待若干时间，区别是wait可以被唤醒，还有wait方法会释放目标对象的锁。而sleep（）不会。

7 挂起（suspend）和继续执行（resume）

• 被挂起的线程，必须等到resume（）操作后，才能继续执行。
• suspend是被废弃的方法：被挂起的线程在导致线程暂停的同时，并不会释放任何锁资源。导致其他线程想要访问被它暂用的锁资源，都会受牵连。
• 怎样用一种可靠的方式使用suspend（）？
  利用wait（）和notify（）方法,在应用层实现suspend 和resume 功能。

package com.sean.thread;public class GoodSuspend{public static Object u = new Object();public static void main(String[] args) throws InterruptedException {ChangeObjThread t1 = new ChangeObjThread();ReadObjThread t2 = new ReadObjThread();t1.start();t2.start();Thread.sleep(1000);t1.suspendMe();System.out.println("suspend t1 2 sec");Thread.sleep(20000);System.out.println("resume t1");t1.resumeMe();}public static class ChangeObjThread extends Thread{volatile boolean suspendme = false;public void suspendMe(){suspendme = true;}public void resumeMe() {suspendme = false;synchronized(this){notify();}}@Overridepublic void run() {while (true) {synchronized (this) {while (suspendme) {try {wait();		//运用等待实现挂起} catch (InterruptedException e) {e.printStackTrace();}}}synchronized(u){System.out.println("in ChangeObjThread");}Thread.yield();}}}public static class ReadObjThread extends Thread{@Overridepublic void run() {while(true){synchronized (u) {System.out.println("in ReadObjThread");}Thread.yield();}}}
}

8 等待线程结束（join）和谦让（yield）

public final void join() throws InterruptedException
public final synchronized void join(long millis) throws InterruptedException

• join（）表示无限等待，它会一直阻塞当前线程，直到目标线程执行完毕。yield（）给出了一个
  最大等待时间，如果超过时间，就会继续往下执行。

• join（）的本质是调用线程wait（）在当前线程对象实例上。当线程执行完成后，被等待的线程 在退出时调用notifyAll通知所有线程继续执行，因此不要在THread对象上使用类似wait、notify等方法，可能会影响api工作。

• Thread.yield 一旦执行，会使当前线程让出CPU。但是并不代表不执行，会有一定几率分配到

public class GoodSuspend {public volatile static int i = 0;public static class AddThread extends Thread {@Overridepublic void run() {for (i = 0; i < 100000000; i++) {}}}public static void main(String[] args) throws InterruptedException {AddThread at = new AddThread();at.start();at.join();System.out.println(i);}
}

3 volatile 与java内存模型(JMM)

1 java内存模型：围绕着原子性、有序性和可见性展开的。但是可以利用关键字或特殊操作，告诉虚拟机有些地方需要特别
注意,比如 volatile。
2 volatile：

• 使用 volatile 去申明一个变量时，在程序范围内的所有其他线程“可见”的，虚拟机就会小心处理这种情况；
• volatile并不能代替锁，也无法保证一些复合操作的原子性，当两个线程同时修改数据时，依然会产生冲突。
• volatile能保证数据的可见性和有序性。

//volatile无法保证一些复合操作
public class GoodSuspend {static volatile int i = 0;public static class PlusTask implements Runnable{@Overridepublic void run() {for (int k = 0; k < 10000; k++){i++;};}}public static void main(String[] args) throws InterruptedException {Thread[] task = new Thread[10];for (int i = 0; i < 10; i++) {task[i] = new Thread(new PlusTask());task[i].start();}for (Thread thread : task) {thread.join();}System.out.println(i);}
}

4 线程组

---

1. 和一个篮子一样，篮子里的每个水果是线程。

public class ThreadGroupName implements Runnable {static volatile int i = 0;public static void main(String[] args) {ThreadGroup tg = new ThreadGroup("PrintGroup");Thread t1 = new Thread(tg, new ThreadGroupName(), "T1");	//定义线程并加入到线程组Thread t2 = new Thread(tg, new ThreadGroupName(), "T2");t1.start();t2.start();System.out.println(tg.activeCount());tg.list();}@Override//输出线程信息public void run() {String groupAndName = Thread.currentThread().getThreadGroup().getName() + Thread.currentThread().getName();while (true) {System.out.println("I am group " + groupAndName);try {Thread.sleep(3000);} catch (InterruptedException e) {e.printStackTrace();}}}
}

5 驻守后台：守护线程（Daemon）

---

• 守护线程：系统的守护者，默默完成系统的一些系统性的服务，比如垃圾回收线程、JIT线程就可以理解为守护线程。与之相对应的是用户线程（系统的工作线程）。
• 要在start（）之前设置守护线程，否则抛出异常，当成用户线程使用。

Thread t = new DaemonT();
t.setDaemon(true);	//设置守护线程
t.start();

6 线程优先级：先做重要的事

---

• 优先级越高，资源竞争越有优势，更可能抢占资源。
• 优先级产生的后果无法精准控制，可能出现低优先级一直抢占不到资源，一直无法运行，从而产生饥饿现象.
• 自己在应用层解决线程调度的问题。
  • 数字越大优先级越高；有效范围在1-10。

public class PriorityDemo{public static void main(String[] args) {//高权限和低权限的线程做同一件事HightPriority h = new HightPriority();LowPriority l = new LowPriority();h.setPriority(Thread.MAX_PRIORITY);//线程设置为高权限l.setPriority(Thread.MIN_PRIORITY);//线程设置为低权限l.start();h.start();}//~做同一件事情总是高权限线程先完成public static class HightPriority extends Thread{static int count = 0;public void run(){while(true){synchronized (PriorityDemo.class) {//使用同步产生资源竞争,而权限高低会去竞争锁资源count++;if (count > 1000000) {System.out.println("HightPriority is complete!");break;}}}}}public static class LowPriority extends Thread{static int count = 0;public void run(){while(true){synchronized (PriorityDemo.class) {count++;if (count > 1000000) {System.out.println("LowPriority is complete!");break;}}}}}
}

7 线程安全与synchronized

---

• 多线程的写入冲突（线程不安全）：当两个线程同时修改一个共享对象，产生覆盖的现象。
  比如，有一个共享对象int i，线程A和线程B都对i 累加10000次，我们想要的结果是20000，但我们得到的结果总是小于这个值。

• 即使用volatile这种关键字也是如此，因为volatile不能解决两个线程同时修改共享对象的问题。

public class AccountingVol implements Runnable{public static volatile int i = 0;@Overridepublic void run() {for (int k = 0; k < 1000000; k++) {i++;}}public static void main(String[] args) throws InterruptedException {AccountingVol v1 = new AccountingVol();Thread t1 = new Thread(v1);  //此行和下面一行的Runnable实例一定要是同一个，这样才能保证在两个线程工作时，关注到同一个对象锁上，从而保证线程安全。Thread t2 = new Thread(v1);t1.start();t2.start();t1.join();	//主线程愿意等到该线程执行完再执行t2.join();System.out.println(i);}
}

• 使用 synchronized 来解决线程安全的问题
  • 用法:
    • 指定加锁对象：对给定对象加锁，进入同步代码前要获得给定对象的锁。
    • 直接作用于实例对象：相当于对当前实例加锁，…。
    • 直接作用于静态方法：相当于对当前类加锁，进入同步块要获得当前类的锁。
  • 当线程进入被synchronized包裹的代码块，必须先请求锁，如果有其他线程正在持有这把锁，则新到的线程就必须等待。

//将上例中的run加上一个同步块
synchronized (v1) {		//同步块，只有一个持有锁的线程可进入for (int k = 0; k < 1000000; k++) {i++;}
}

• 可将synchronized关键字作用于一个实例方法：意思是进入该方法前，线程需获得当前对象实例的锁。

//上面同步块代码转为一个方法，这种事获取当前对象实例的锁
public synchronized void increase(){i++;
}
for (int k = 0; k < 1000000; k++) {this.increase();
}

• 想要保证两个线程的线程安全，必须要两个线程都指向同一个Runnable实例接口，这样才能使两个线程关注到同一个对象锁上，既要使用同一把锁，才能保证线程安全，使用下面方法也可以正确执行。

//这样使用的是当前类的锁，即使不是同一个Runnable对象，也可以正确执行
public static synchronized void increase（）｛i++；
｝

8 程序中的幽灵：隐藏的错误

• 案例：比如两个数相加导致int的溢出，就会导致出现负数的情况

• 并发下的 ArrayList：ArrayList 是不安全的，可用 Vector 代替 ArrayList

• 并罚下的诡异的 HashMap：

  • 可能有三种情况：
    • 1 程序正常结束；2 程序正常结束，不符合预期； 3 程序死循环（链表遭到破坏，链表成环）；

• 错误的加锁：

  • 最好别加在Integer对象上，Integer对象在做++运算时是创建一个新的Integer对象的，String对象也是如此。