线程概念
- 与进程的关系
进程是操作系统分配内存及其他系统资源的基本单元，线程之间相互独立。线程是操作系统分配CPU的基本单元，但共享内存和其他系统资源。线程切换速度比进程要快。 - 操作系统使用时间片轮转算法来给线程分配CPU，不同的系统策略不同。
-
线程有状态：新建，就绪，阻塞，运行，死亡。
具体的线程调用start（）就是就绪状态，等待JVM的调度，等获得CPU就进入运行状态，此时可能发生阻塞（资源不足）或者就绪（时间片用完）。
java thread status - 线程的优先级priority
- 优先级范围为：1（THREAD.MIN_PRIORITY）-10（THREAD.MAX_PRIORITY），默认为5(THREAD.NORM_PRIORITY)
- 线程创建时，子线程继承父线程的优先级，可以通过setPriority()来改变线程的优先级。
多线程的相关操作
继承Thread类创建线程类，重写run方法。
class myThread extends Thread{
public void run(){}
}
public class ThreadRun extends Thread{
public void run(){
System.out.println("other thread:"+Thread.currentThread().getName());
for(int i=0;i<10;i++){
System.out.println(i);
}
}
public static void main(String[] args){
System.out.println("main thread:"+Thread.currentThread().getName());
ThreadRun t = new ThreadRun();
ThreadRun s = new ThreadRun();
t.start();
s.start();
}
}
实现Runnable接口创建线程类，覆盖run方法。
接口原型：
public interface Runnable{ public void run(){} }
封装：class MyThread implements Runnable{ public void run(){} }
运行方法：
创建一个Runable对象：
Runnable r = new MyRunnable();
将Runable对象传给Thread对象
Thread t = new Thread(r);
启动多线程运行：
t.start();
class MyThread implements Runnable {
@Override
public void run() {
System.out.println("mythread start:" + Thread.currentThread().getName());
for (int i = 0; i < 10; i++) {
System.out.println(i);
}
System.out.println("mythread end:" + Thread.currentThread().getName());
}
}
public class RunnableThreadTest {
public static void main(String[] args) {
System.out.println("mainTHread start:" + Thread.currentThread().getName());
Thread t = new Thread(new MyThread(), "mythread"); // create thread.
t.start();
System.out.println("mainTHread end:" + Thread.currentThread().getName());
}
}
匿名线程类
注意匿名类的写法，愤青最后运行的是那个run方法。
public class RunWhatThread {
public static void main(String[] args) {
Thread th = new Thread(new Runnable() {
@Override
public void run() {
System.out.println("runnable");
}
}) {
@Override
public void run() {
//super.run();
System.out.println("thread");
}
};
th.start();
}
}
通过线程工厂创建线程
接口原型：public interface ThreadFactory{ Thread newThread( Runnable r){} }
实现此接口，就可以使用工厂模式来创建线程，只需一条语句，使创建线程更方便。
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.concurrent.ThreadFactory;
public class ThreadFactoryDemo {
public static void main(String[] args) {
MyThreadFactory factory = new MyThreadFactory("thread factory");
factory.newThread(new Runnable() {
@Override
public void run() {
System.out.println("in runnable");
}
}).start();
}
}
class MyThreadFactory implements ThreadFactory {
private int count;
private String name;
private List<String> stats;
public MyThreadFactory(String name) {
count = 0;
this.name = name;
stats = new ArrayList<>();
}
public Thread newThread(Runnable r) {
Thread t = new Thread(r, name + "-thread-" + count);
count++;
stats.add(String.format("create thread %d with name %s on %s\n", t.getId(), t.getName(), new Date()));
return t;
}
}
后台Daemon线程
后台线程相对前台线程而言，当主线程结束时，后台线程也会自动结束。
默认情况下，创建的线程均为“前台”线程，需要调用setDeamon方法设置为“背景”线程：thread.setDaemon(true);
线程的暂停
- 静态方法 Thread.sleep(long mills)，需捕获InterruptedException 异常
- 使用TimeUnit枚举类的相应方法，TimeUnit.SECONDS.sleep(long s)
import java.util.concurrent.TimeUnit;
public class ThreadSleep {
public static void main(String[] args) {
Thread t = new Thread(new Runnable() {
private int count = 0;
@Override
public void run() {
for (int i = 0; i < 10; i++) {
try {
//Thread.sleep(500); //sleep 单位是毫秒
TimeUnit.SECONDS.sleep(1); //单位可以自定义,more convinent
} catch (InterruptedException e) {
e.printStackTrace();
}
count++;
System.out.println(count);
}
}
});
t.start();
}
}
线程终止
- 当执行完毕，发生未捕获的异常，其他线程请求终止该线程时，线程会发生终止。
- 可以通过interrupt（）向进程发送中断请求，此时内部的中断标志会被设置，通常需要定时检测这一标志。
import java.util.concurrent.TimeUnit;
public class PrimerGenerator extends Thread {
@Override
public void run() {
long number = 0L;
while (true) {
if (isPrimer(number)) {
System.out.println(number + " is a primer");
}
// 定时检查线程的中断标志
if (isInterrupted()) {
System.out.println("thread already is interrupted");
return;
}
number++;
}
}
private boolean isPrimer(long n) {
if (n < 2) {
return false;
}
for (int i = 2; i < n; i++) {
if (n % i == 0)
return false;
}
return true;
}
public static void main(String[] args) {
Thread task = new PrimerGenerator();
task.start();
try {
TimeUnit.SECONDS.sleep(5);
} catch (InterruptedException e) {
e.printStackTrace();
}
task.interrupt();
}
}
定时任务
使用Timer类的schedule方法可以定时执行一个任务。此任务是TimerTask类型的实例，注意TimerTask派生自Runnable。因此，会在另外一个线程中运行这个定时任务。
import java.util.Timer;
import java.util.TimerTask;
public class UseTimer {
public static void main(String[] args) {
//TimerTask定时任务，继承Runnable接口
TimerTask task = new TimerTask() {
private int count = 0;
@Override
public void run() {
count++;
System.out.println(count + ":invoked.");
}
};
Timer timer = new Timer();
//第一个参数是TimerTask表示待执行的任务，第二个参数是第一次调用的时间，第二个参数表示第一次调用之后，从第二次开始每隔多长的时间调用一次 run()方法。
timer.schedule(task, 2000, 3000);
}
}
线程组
- 将一批线程组做成统一的组管理，每个组有各自的名字，可有父子关系。
- ThreadGroup parent=new ThreadGroup(“parent”)
ThreadGroup child=new ThreadGroup(parent,”Child”) - 向线程组增加新线程
Thread t1=new Thread(parent,”t1”) - 线程有未捕获的异常，需要通过Thread.UncaughtExceptionHandler接口来处理， 此接口定义了以下方法：
void uncaughtException(Thread t, Throwable e) - 如果没有设定线程的未捕获异常处理对象，将会使用线程的ThreadGroup对象，它实现了Thread.UncaughtExceptionHandler接口。使用线程组可以统一管理未捕获异常。
public class ThreadGroupDemo {
public static void main(String[] args) {
ThreadGroup threadGroup = new ThreadGroup("group1"){
public void uncaughtException(Thread t,Throwable e){
System.out.println(t.getName()+":"+e.getMessage());
}
};
Thread thread = new Thread(threadGroup,new Runnable() {
@Override
public void run() {
throw new RuntimeException("throw the exception to test the uncaughedexception");
}
});
thread.start();
}
}
