Java并发编程（一）——线程

Java并发编程（一）——线程

一，线程的实现方式

　　Java中实现多线程有两种方式，如下：

1，继承java.lang.Thread类，重写run()方法；
2，实现java.lang.Runnable接口，重写接口中的run()方法。

　　这两种实现方式没有优劣，但由于Java中不允许多继承，所以使用第二种实现接口的方式更加灵活。

　　另外需要注意的是实现了Runnable的类，就像其字面描述的意思一样，只是一个可运行的东西，最终也是要Thread类来启动它，它才能跑起来。这一点从源码上分析来看，只能说Runnable接口只是为了用来在不能多继承的情况下来实现多线程而设计的，最终线程的内容和启动还是Thread来实现的。

　　代码如下：

public class ThreadDemo {
public static void main(String[] args) {
Thread t = new Thread();
t.start();

Thread t2 = new Thread(new Line());
t2.start();
}
}
class Line implements Runnable{

@Override
public void run() {
System.out.println("Line Thread is running...");
}
}

　　而更多的情况下，我们会采用匿名内部类来实现多线程：

public static void main(String[] args) {
new Thread(new Runnable() {
@Override
public void run() {
System.out.println("I'm a new Thread");
}
}).start();
}

二，线程的生命周期

　　线程的生命周期是指一个线程从创建到消亡的过程。

新建状态（New）

　　当用new操作符创建一个新的线程对象时，该线程处于创建状态。处于创建状态的线程只是一个空的线程对象，系统不为它分配资源。

注意：不能对已经启动的线程再次调用start()方法，否则会出现java.lang.IllegalThreadStateException异常。如下：

Thread t = new Thread(new Runnable() {
@Override
public void run() {
try {
Thread.sleep(3000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("I'm a new Thread");
}
});
t.start();
t.start();//同一个(同id)线程不能同时启动两次

另，线程是不能clone的，因为线程id是不能重复的，会抛出CloneNotSupportedException异常，见源码：

@Override
protected Object clone() throws CloneNotSupportedException {
throw new CloneNotSupportedException();
}

就绪状态（Runnable）

　　线程对象创建后，其他线程调用了该对象的start()方法。该状态的线程位于可运行线程池中，变得可运行，等待获取CPU的使用权。

运行状态（Running）

　　就绪状态的线程获取了CPU的使用权，执行程序代码的过程就处于运行态。

阻塞状态（Blocked）

　　阻塞状态是线程因为某种原因放弃CPU使用权，暂时停止运行。直到线程进入就绪状态，才有机会转到运行状态。阻塞的情况分三种：

（1）等待阻塞：运行的线程执行wait()方法，JVM会把该线程放入等待池中。

（2）同步阻塞：运行的线程在获取对象的同步锁时，若该同步锁被别的线程占用，则JVM会把该线程放入锁池中。

（3）其他阻塞：运行的线程执行sleep()或join()方法，或者发出了I/O请求时，JVM会把该线程置为阻塞状态。当sleep()状态超时、join()等待线程终止或者超时、或者I/O处理完毕时，线程重新转入就绪状态。

死亡状态（Dead）

　　线程执行完了或者因异常退出了run()方法，该线程结束生命周期。

三，线程状态的转换

1，线程生命周期图





2，线程状态的切换方式：

1）yield()：yield的意思是让步，让出，就是暂时让出CPU的使用权，所以从Running变为了Runnable状态。

2）sleep()：使线程睡眠一定的时间，由Running态变为Blocked态。

3）join()：使当前线程(如主线程)挂起，直到调用join方法的线程执行完毕。

4）exit()：在线程进入Running之前可以清空并退出该线程。

5）stop()：强制线程退出，

已废弃

。

6）suspend()：挂起线程，由Running变为Blocked，和resume相对应，

已废弃

。

7）resume()：恢复线程，由Blocked变为Runnable，

已废弃

。

8）interrupt()：打断/中断线程。

四，Thread类的常用API

void setName(String name)

：为线程设置线程名；

　　守护线程和用户线程的区别在于：守护线程依赖于创建它的线程，而用户线程则不依赖。举个简单的例子：如果在main线程中创建了一个守护线程，当main方法运行完毕之后，守护线程也会随着消亡。而用户线程则不会，用户线程会一直运行直到其运行完毕。在JVM中，像垃圾收集器线程就是守护线程。

void setDaemon(boolean on)

：设置是否是守护线程，是谁的守护线程？是当前线程的守护线程；需要在start方法调用之前使用；另，在Daemon线程中产生或新建的新线程默认也是Daemon的。

public class DaemonDemo {

public static void main(String[] args) throws InterruptedException {
TestThread test = new TestThread();
// 如果不设置daemon，那么线程将输出10后才结束
test.setDaemon(true);
test.start();
System.out.println("isDaemon = " + test.isDaemon());
try {
System.in.read(); // 接受输入，使程序在此停顿，一旦接收到用户输入，main线程结束，守护线程自动结束
} catch (IOException ex) {
ex.printStackTrace();
}
}
}

class TestThread extends Thread {
public void run() {
for (int i = 1;; i++) {
try {
Thread.sleep(1000);
} catch (InterruptedException ex) {
ex.printStackTrace();
}
System.out.println(i);
}
}
}

boolean isDaemon()

：判断是否是守护线程；

void setPriority(int newPriority)

：设置线程优先级，默认为5，最小为1，最大为10；优先级越高，越能更早的获取CPU调度；

Thread currentThread()

：返回当前线程对象的一个引用，为什么不用this？见下篇博客

int activeCount()

：返回当前线程所在的线程组中活跃线程的数量；