多线程技术概述

进程

是指一个内存中运行的应用程序，每个进程都有一个独立的内存空间

线程

是进程中的一个执行路径，共享一个内存空间，线程之间可以自由切换，并发执行. 一个进程最少有一个线程

线程实际上是在进程基础之上的进一步划分，一个进程启动之后，里面的若干执行路径又可以划分成若干个线程

文章目录

多线程技术概述
线程调度
同步与异步
并行与并发
开启多线程技术
设置和获取线程名称
线程的休眠 sleep
线程的堵塞
线程中断
守护线程

线程调度

分时调度

所有线程轮流使用 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();
                }
            }
        }
    }
}

多线程看完你就懂