第8章 线程
线程可以让一个程序同时执行多个任务，在实际程序应用地非常广泛。
8.1 理解线程
8.1.1进程的概念
了解线程前先了解一下进程，进程可以看成是程序的执行，可以把一个程序的执行过程看成是一个进程。
比如我们打开一个Word程序，就有一个Word程序进程。
8.1.2 线程的概念（此处是个人理解。）
一个进程可以有多个线程，同时执行多个任务。同样用Word举例，Word显示可以看成是一个线程，编辑可以看出是一个线程。
8.1.3 线程的生命周期
线程的生命周期有4种基本状态：
1.产生
2.中断
3.非中断（运行或可运行）
4.退出
8.2 线程类设计
8.2.1 线程API类图
Thread类是线程实现的主类，其核心过程方法由Runnable接口规范。
8.2.2 线程类Thread的构造方法
1.Thread(String threadName); //创建指定名称的线程类
2.Thread(); //线程类名称系统自动指定Thread-编号
3.Thread(Runnable target) //target为目标对象，target需要实现Runnable接口，给出run()方法。
8.3 线程实现
线程的实现一般有两种方式：
（1）创建Thread类的子类，并重新定义run()方法，用户只要创建子类对象就能建立自己的线程。
（2）创建实现Runnable接口的类，并实现run()方法。
8.3.1 继承实现
方式一：继承Thread类
public class ThreadDemo extends Thread{
public void run() {
//线程代码实现
System.out.println("线程执行");
}
public static void main(String[] args) {
ThreadDemo th = new ThreadDemo();
th.start();
}
}8.3.2接口实现
方式二：实现Runnable接口
public class ThreadDemo2{
public static void main(String[] args) {
Thread th = new Thread(new MyThImpl());
th.start();
}
}
class MyThImpl implements Runnable{
public void run() {
//线程代码实现
System.out.println("线程执行");
}
}
8.4 线程控制
8.4.1 监控线程状态
线程状态在枚举类型Thread.State中定义。
NEW：新创建，还没调用start()
RUNNABLE：run()中代码被执行
BLOCKED：阻塞，等待解锁
WAITING：另一个线程运行，本线程等待
TIMED_WAIYING：等待到指定时间
TERMINATED：线程退出run（）
获取线程状态方法：
public Thread.State getState()
8.4.2 线程休眠
Thread的sleep()方法
public class sleep1 {
public static void main(String[] args) throws InterruptedException {
for(int i=0;i<20;i++) {
System.out.println("main"+i);
Thread.sleep(1000);
}
}
}注意：（1）sleep是静态方法，睡眠的是当前运行的线程、
8.4.3 中断线程
public void interrupt() ：中断当前阻塞与等待状态，强制线程抛出异常。
8.4.4 阻塞进程 join()
void join(): 当前线程等待加入该线程后面，等待该线程终止
void join(long millis):当前线程等待该线程终止的时间最长为millis毫秒，如果超时还没执行完，当前线程也会进入就绪状态。
void join(long millis, int nanos);等待时间millis毫秒+nanos纳秒
8.4.5线程等待和唤醒
public final void wait() throws InterruptedException public final void wait(long timeout,int nanos)throws InterruptedException void notify() void notifyAll()
如果线程等待用sleep()，唤醒用interrupt()
等待用join()，唤醒用interrupt()
等待用wait（），唤醒用notify();
8.4.6线程终止
当前线程放弃调度执行权力，等待下次排队执行。
public static void yield()
..线程控制综合实例
import java.util.Scanner;
public class sleep1 {
private static int data = -1;
private static Thread thread = new Thread(new Runnable() {
public void run() {
System.out.println("线程已经启动，输入0开始计数");
for(int i=10;i>0;i--) {
while(data != 0) {
Thread.yield();
}
System.out.println(Thread.currentThread().getName()+":"+i);
try {
Thread.sleep(100);
}catch(InterruptedException e) {
e.printStackTrace();
}
}
}
});
public static void main(String[] args) {
thread.start();
Scanner in = new Scanner(System.in);
while(data == -1) {
try {
data=Integer.parseInt(in.nextLine());
if(data!=0) {
System.out.println("enter 0 to start counting");
data = -1;
}
}catch(NumberFormatException e) {
System.out.println("请输入整数");
}
}
in.close();
}
}8.5 线程属性
8.5.1 优先级
优先级较高的线程获取CPU资源的概率较大。
每个线程默认的优先级和父线程相同。
Thread类提供setPriority(int newPriority和getPriority)和getPriority()方法来设置和得到优先级。
setPriority的参数时一个整数，范围1~10. （10最高）。
优先级实例：
public class priority1 {
public static void main(String[] args) {
new MyThread("低级",1).start();
new MyThread("高级",10).start();
}
}
class MyThread extends Thread{
public MyThread(String name,int pro) {
super(name);
setPriority(pro);
}
public void run() {
for(int i=0;i<=100;i++) {
System.out.println(this.getName()+"线程第"+i+"次执行");
}
}
}多次运行可以发现，多数情况下优先级高的先运行完成。
8.5.2 守护线程
Java中有两类线程：用户线程User Thread 和 守护线程Daemon Thread
守护线程具有最低优先级，为系统其它对象提供服务。
一般不会自己操作守护进程。
8.6线程同步
8.6.1Synchronized同步方法和同步代码块
保护某段代码只能同时被一个线程执行的技术成为线程同步。
关键字synchronized是Java内部实现的一个简单锁，可以用synchronized锁定一段代码：
public static void biz() {
synchronized(Object.class) {
a++;
b++;
if(a!=b) {
System.out.println(a+"!="+b);
}
}
}或者锁定整个方法：
synchronized public static void biz() {
a++;
b++;
if(a!=b) {
System.out.println(a+"!="+b);
}
}
8.6.2 同步变量volatile关键字
Java变量前可以加修饰语volatile，volatile的主要目的是解决成员变量的多线程访问同步问题。
在读取加了volatie修饰的变量时，会直接从内存读取。
但volatile不保证对变量的操作是原子操作。
Java提供java.util.concurrent.automic包，提供了基本类型与引用类型的原子性操作封装类：
AtomicBoolean
AtomicInteger
AtomicIntegerArray
...
8.6.3线程锁Lock接口及ReentrantLock类
...
8.6.4 死锁
不同线程都在等待那些不可能被释放的锁时，就成了死锁。
构成死锁的典型是锁交叉。
