近期在学习java线程,这是学习的总结。
参考资料
概念
http://www.runoob.com/java/java-multithreading.html
上下文切换
https://www.cnblogs.com/xrq730/p/5186609.html
https://blog.csdn.net/u014527912/article/details/78939781
java多线程的同步锁机制
https://www.cnblogs.com/gavin110-lgy/p/5716421.html
http://www.cnblogs.com/hapjin/p/5452663.html
https://www.cnblogs.com/lwbqqyumidi/p/3821389.html
线程生命周期
https://www.cnblogs.com/lwbqqyumidi/p/3804883.html
https://www.cnblogs.com/lwbqqyumidi/p/3817517.html
https://blog.csdn.net/Yoryky/article/details/78515818
https://www.cnblogs.com/sunddenly/p/4106562.html
知识点
- 线程和进程的基本概念
- 线程的生命周期
- 线程的创建和启动
- 守护线程和用户线程
- 线程的调度和优先级
- 上下文切换
- 线程同步
线程和进程的基本概念
线程和进程的区别和联系
- 线程是程序执行的最小单元。是被系统独立调度和分派的基本单位。
- 线程自己不拥有系统资源,只拥有一点儿在运行中必不可少的资源。但它可与同属一个进程的其它线程共享进程所拥有的全部资源,包括代码、数据空间。
- 进程包括由操作系统分配的内存空间,包含一个或多个线程。一个进程一直运行,直到所有的非守护线程都结束运行后才能结束。java运行环境就是一个单一进程。
- 每个进程都有独立的代码和数据空间,进程间的切换会有较大的开销;相比而言,同一进程下的线程切换的开销较小。
- 多个线程被并发的执行可以提高程序的效率,CPU不会因为某个线程需要等待资源而进入空闲状态。
线程的生命周期
线程的创建和启动
java的线程是通过java.lang.Thread类实现的。JVM启动时会有一个由主方法(public static void main(){})定义的线程。
每个线程都是通过某个特定Thread对象所对应的方法run()来完成操作,方法run()称为线程体。通过Thread的start()启动线程,线程启动后执行。Thread的run()方法可以被直接调用,但是,直接调用就和普通方法一样了。
另外,不能对同一线程对象两次调用start()方法。
创建新线程
Java 提供了三种创建线程的方法:
1. 通过实现 Runnable 接口;
- 线程类R1实现Runnable接口
- Thread t1 = new Thread(new R1());
- Runnable中只有run()一个方法,用于定义线程运行体。
package indi.thread.part01;
/**
* 三种创建线程的方法:1/3
* @author 61940
*
*/
public class MainTest01 {
public static void main(String[] args) {
// TODO Auto-generated method stub
Thread t = null;
for (int i = 0; i < 100; i++) {
MyRun run = new MyRun();
run.start();
MyRun.add();
}
System.out.println("Main id>>" + 1);
}
}
class MyRun implements Runnable {
private static int id = 0;
private Thread t = null;
private String threadName = "";
public static int add() {
return id++;
}
public void start(){
threadName = "thread" + id;
if(t == null){
t = new Thread(this,threadName);
System.out.println("start线程:" + threadName);
t.start();
}
}
@Override
public void run() {
System.out.println("run线程:" + threadName);
}
}
2. 通过继承 Thread 类本身;
- 线程类继承Thread并重写其run()方法;
- 生成线程类实例并执行start();
package indi.thread.part01;
/**
* 三种创建线程的方法:2/3
* @author 61940
*
*/
public class MainTest02 {
public static void main(String[] args) {
MyThread1 mt = null;
for (int i = 0; i < 100; i++) {
mt = new MyThread1();
mt.start();
}
}
}
class MyThread1 extends Thread{
private static int id = 0;
public MyThread1(){
super();
}
public void start(){
System.out.println("start线程:" + id);
super.start();
}
public int add() {
return ++id;
}
public void run(){
System.out.println("id>>" + add());
}
}
3. 通过 Callable 和 Future 创建线程。
- Callable 接口类似于 Runnable,两者都是为那些其实例可能被另一个线程执行的类设计的。但是 Runnable 不会返回结果,并且无法抛出经过检查的异常。Callable可以做到。
- 线程启动时调用Callable的call()。
- 通过FutureTask的get()可以获取子线程的返回值。
package indi.thread.part01;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
/**
* 三种创建线程的方法:3/3
* @author 61940 实现Callable<T>接口,call()的返回值类型与T一致,启动线程时,调用call()方法,
*/
public class MainTest03 {
public static void main(String[] args) {
try {
for (int i = 0; i < 100; i++) {
System.out.println(Thread.currentThread().getName() + i);
CallThread ct = new CallThread();
FutureTask ft = ct.getFutureTask();
new Thread(ft,("子线程" + i)).start();
System.out.println("返回值" + ft.get());
}
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (ExecutionException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
class CallThread implements Callable<String> {
@Override
public String call() throws Exception {
Thread.currentThread().sleep(1000);
System.out.println(Thread.currentThread().getName());
return Thread.currentThread().getName();
}
public FutureTask<String> getFutureTask() {
FutureTask<String> ft = new FutureTask<String>(this);
return ft;
}
}
守护线程和用户线程
- 为程序其他线程(可以理解为前台线程)提供服务,如JVM的垃圾回收线程。
- 守护线程的生命周期与前台线程有一定的关联,具体表现为当所有的前台线程进入死亡状态后,守护线程自动死亡。
- 设置守护线程:调用Thread对象的setDaemon(true)方法可以将指定的线程设置为守护线程。
- 判断线程是否是守护线程:调用thread对象的isDeamon()方法。
- main线程默认是前台线程,前台线程创建中创建的子线程默认是前台线程,守护线程中创建的子线程默认是守护线程。
- 如果需要将前台线程设置为守护线程,需要在start()方法调用之前调用调用setDeamon(true)方法。
- 前台线程都死亡后,JVM通知守护线程死亡,但从接收指令到作出响应,需要一定的时间。
线程的调度和优先级
- 每一个 Java 线程都有一个优先级,这样有助于操作系统确定线程的调度顺序。
- Java 线程的优先级是一个整数,其取值范围是 1 (Thread.MIN_PRIORITY) - 10 (Thread.MAX_PRIORITY)。
- 默认情况下,每一个线程都会分配一个优先级 NORM_PRIORITY(5)。可以用setPriority(int priority)
- 具有较高优先级的线程对程序更重要,并且应该在低优先级的线程之前分配处理器资源。但是,线程优先级不能保证线程执行的顺序,而且非常依赖于平台。
上下文切换
多线程环境中,当一个线程的状态由Runnable转换为非Runnable(Blocked、Waiting、Timed_Waiting)时,相应线程的上下文信息(包括cpu的寄存器和程序计数器在某一时间点的内容等)需要被保存,以便相应线程稍后再次进入Runnable状态时能够在之前的执行进度的基础上继续前进。而一个线程从非Runnable状态进入Runnable状态可能涉及恢复之前保存的上下文信息。这样的对线程的状态的保存和恢复的过程就是上下文切换。
上下文切换会带来额外的开销,这包括对线程上下文信息保存和恢复的开销,对线程进行调度的cpu时间开销以及cpu缓存失效的开销。