多线程技术概述
进程
是指一个内存中运行的应用程序,每个进程都有一个独立的内存空间
线程
是进程中的一个执行路径,共享一个内存空间,线程之间可以自由切换,并发执行. 一个进程最少有一个线程
线程实际上是在进程基础之上的进一步划分,一个进程启动之后,里面的若干执行路径又可以划分成若干个线程
文章目录
线程调度
分时调度
所有线程轮流使用 CPU 的使用权,平均分配每个线程占用 CPU 的时间。
抢占式调度
优先让优先级高的线程使用 CPU,如果线程的优先级相同,那么会随机选择一个(线程随机性),Java使用的为
抢占式调度。
CPU使用抢占式调度模式在多个线程间进行着高速的切换。对于CPU的一个核新而言,某个时刻,只能执行一个线程,而 CPU的在多个线程间切换速度相对我们的感觉要快,看上去就是在同一时刻运行。其实,多线程程序并不能提高程序的运行速度,但能够提高程序运行效率,让CPU的使用率更高。
同步与异步
同步:排队执行,效率低但是安全。
异步:同步执行,效率高但是数据不安全。
并行与并发
并发:指两个或多个事件在同一个时间段内发生。
并行:指两个或多个事件在同一时刻发生(同时发生)。
开启多线程技术
1.继承Thread
public class MyThread extends Thread{
/**
*run方法就是线程要执行的任务方法
*/
@Override
public void run(){
//这里的代码 就是一条新的执行路径.
//这个执行路径的方式,不是调用run方法,而是通过Thread对象的start()来启动任务。
for(int i=0;i<10;i++){
System.out.println("锄禾日当午"+i);
}
}
}
public static void main(String[] args){
MyThread m = new MyThread();
m.start();
for(int i=0;i<10;i++){
System.out.println("汗滴禾下土"+i);
}
}
每个线程都拥有自己的栈空间,共用一份堆内存
2.实现Runnable
实现Runnable 与 继承Thread相比有如下的优势:
- 通过创建任务,然后给线程分配的方式来实现的多线程,更适合多个线程同时执行相同任务的情况
- 可以避免单继承所带来的局限性.
- 任务与线程本身是分离的,提高了程序的健壮性.
- 后续学习的线程池技术,接收Runnable类型的任务,不接受Thread类型的线程。
public class MyRunnable implements Runnable{
@Override
public void run(){
//线程的任务
for(int i=0;i<10;i++){
System.out.println("锄禾日当午"+i);
}
}
}
public static void main(String[] args){
//实现Runnable
//1. 创建一个任务对象
MyRunnable r = new MyRunnable();
//2. 创建一个线程,并为其分配一个任务
Thread t = new Thread(r);
//3. 执行这个线程
t.start();
for(int i=0;i<10;i++){
System.out.println("锄禾日当午"+i);
}
}
3.带返回值得线程Callable
Runnable 与 Callable
接口定义
//Callable接口
publicinterfaceCallable<V> {
Vcall()throwsException;
}
//Runnable接口
public interface Runnable {
publicabstractvoidrun();
}
Runnable 与 Callable相同点
1.都是接口
2.都可以编写多线程程序
3.都采用Thread.start()启动线程
Runnable 与 Callable不同点
1.Runnable没有返回值;Callable可以返回执行结果
2.Callable接口的call()允许抛出异常;Runnable的run()不能抛出
Callable获取返回值
Callalble接口支持返回执行结果,需要调用FutureTask.get()得到,
此方法会阻塞主进程的继续往下执行,如果不调用不会阻塞。
设置和获取线程名称
public static void main(String[] args){
//如何获取线程的名称
System.out.println(Thread.currentThread().getName());
newThread(new MyRunnable(),"锄禾日当午").start();
}
static class MyRunnable implements Runnable{
@Override
public void run(){
System.out.println(Thread.currentThread().getName());
}
}
public static void main(String[] args){
//如何获取线程的名称
System.out.println(Thread.currentThread().getName());
newThread(new MyRunnable(),"").start();
newThread(new MyRunnable(),"").start();
newThread(new MyRunnable(),"").start();
}
static class MyRunnable implements Runnable{
@Override
public void run(){
System.out.println(Thread.currentThread().getName());
}
}
线程的休眠 sleep
public static void main(String[] args){
//线程的休眠 sleep
for(int i=0;i<10;i++){
System.out.println(i);
Thread.sleep(1000);//休息一秒钟,指定时间休眠
}
}
线程的堵塞
耗时操作
线程中断
public static void main(String[] args){
//线程中断
//一个线程是一个独立的执行路径,他是否应该结束,应该由自身决定
//早期提供stop 过时,会直接插死
}
package thread;
public class Demo5 {
public static void main(String[] args) {
//线程中断
//y一个线程是一个独立的执行路径,它是否结束应该由其自身决定
Thread t1 = new Thread(new MyRunnable());
t1.start();
for (int i = 0; i < 5; i++) {
System.out.println(Thread.currentThread().getName()+":"+i);
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
//给线程t1添加中断标记
t1.interrupt();
}
static class MyRunnable implements Runnable{
@Override
public void run() {
for (int i = 0; i < 10; i++) {
System.out.println(Thread.currentThread().getName()+":"+i);
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
//e.printStackTrace();
System.out.println("发现了中断标记,线程自杀");
return;
}
}
}
}
}
守护线程
package thread;
public class Demo6 {
public static void main(String[] args) {
//线程分为守护线程和用户线程
//用户线程:当一个进程不包含任何的存活的用户线程时,进行结束
//守护线程:守护用户线程的,当最后一个用户线程结束时,所有守护线程自动死亡。
Thread t1 = new Thread(new MyRunnable());
//设置守护线程
t1.setDaemon(true);
t1.start();
for (int i = 0; i < 5; i++) {
System.out.println(Thread.currentThread().getName()+":"+i);
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
static class MyRunnable implements Runnable{
@Override
public void run() {
for (int i = 0; i < 10; i++) {
System.out.println(Thread.currentThread().getName()+":"+i);
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
}