十、线程概述_一个任务下来线程是怎么强的-CSDN博客

本文链接：https://blog.csdn.net/luo_li_d/article/details/118343081

线程

程序,进程,线程的概念

程序:为了完成某种特定的让任务,用某种语言编写的一组指令的集合.即指一段静态的代码.

进程:正在执行的程序,进程是操作系统进行资源分配的最小单位.

线程:进程可进一步细分为线程,是一个进程内部的最小执行单元,是操作系统进行任务调度的最小单元,隶属于线程.

线程与进程之间的关系

一个进程可以包含多个线程,一个线程只能属于一个进程.线程不能脱离进程而独立运行.

每一个进程至少包含一个进程(称为主线程);在主线程中开始执行程序.java程序的入口main()方法就是在主线程中被执行的.

在主线程中可以创建并启动其他的线程.

一个进程内的所有线程共享该进程的内存资源.

创建进程

继承Thread类的方式

public class Sample {

    public void method1(String str){
        System.out.println(str);
    }

    public void method2(String str){
        method1(str);
    }

    public static void main(String[] args) {
        Sample s = new Sample();
        s.method2("hello");
    }

}

在java中要实现线程,最简单的方式就是扩展Thread类,重写其中的run方法,方法原型如下:

Thread类中的方法本身并不执行任何操作,如果我们调用重写了的闰方法,当线程启动时,他将执行run方法.

public class MyThread extends Thread{

    public void run(){
    }

}
调用:
MyThread thread = new MyThread();
        thread.run();

实现Runnable接口的方式

Java.lang.Runnable接口中仅仅只有一个抽象方法:

public void run()

也可以通过实现Runnable接口的方式实现线程,只需要实现其中的run方法即可.

Runnable接口的存在主要是为了解决Java中不允许多继承的问题.

public class MyThread implements Runnable{

    @Override
    public void run() {

        //线程执行任务
        MyThread r = new MyThread();
        //创建一个线程作为外壳,将r包含起来
        Thread thread = new Thread(r);
        thread.start();
    }
}

继承方式和实现方式的联系与区别

区别

继承Thread:线程代码存放Thread子类run方法中.

实现Runnable:线程代码存放接口的子类中的run方法中.

实现Runnable的好处

1.避免了单继承的局限性.

2.多个线程可以共享同一个接口实现类的对象，非常适合多个相同线程来处理同一份资源.

Thread类构造方法

Thread() 创建一个新的线程

Thread(String name) 创建一个指定名称的线程

Thread(Runnable target) 利用Runnable对象创建一个线程,启动时将执行该对象的run方法

Thread(Runnable target,String name) 利用Runnable对象创建一个线程,并指定该线程的名称

线程优先级

事实上，计算机只有一个CPU，各个线程轮流获得CPU的使用权，才能执行任务

优先级较高的线程有更多获得CPU的机会，反之亦然；

优先级用整数表示，取值范围是1~10，一般情况下，线程的默认优先级都是5，但是也可以通过setPriority和getPriority方法来设置或返回优先级；

调度策略

时间片

抢占式:高优先级的线程抢占CPU

Java的调度方法

同优先级线程组成先进先出队列，使用时间片策略

对高优先级，使用优先调度的抢占式策略

Thread类有如下3个静态常量来表示优先级

MAX_PRIORITY：取值为10，表示最高优先级。

MIN_PRIORITY：取值为1，表示最底优先级。

NORM_PRIORITY：取值为5，表示默认的优先级

线程状态

线程的生命周期

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-bEre5GFG-1624969069697)(C:\Users\李凯\AppData\Roaming\Typora\typora-user-images\image-20210628193518828.png)]

线程的状态

新建：当一个Thread类或其子类的对象被声明并创建时，新生的线程对象处于新建状态

就绪：处于新建状态的线程被start（）后，将进入线程队列等待CPU时间片，此时它已具备了运行的条件，只是没分配到CPU资源

运行：当就绪的线程被调度并获得CPU资源时，便进入运行状态，run()方法定义了线程的操作和功能

阻塞：在某种特殊情况下，被人为挂起或执行输入输出操作时，让出 CPU并临时中止自己的执行，进入阻塞状态

死亡：线程完成了它的全部工作或线程被提前强制性地中止或出现异常导致结束

线程的分类

用户线程

守护线程

多线程

多线程的概念

多线程是指程序中包含多个执行单元，即在一个程序中可以同时运行多个不同的线程来执行不同的任务，也就是说允许单个程序创建多个并行执行的线程来完成各自的任务.

多线程的用处

程序需要同时执行两个或多个任务。

程序需要实现一些需要等待的任务时，如用户输入、文件读写操作、网络操作、搜索等。

需要一些后台运行的程序时。

多线程的优缺点

优点

提高程序的响应.

提高CPU的利用率.

改善程序结构,将复杂任务分为对个线程,独立运行

缺点

线程也是程序，所以线程需要占用内存，线程越多占用内存也越多；

多线程需要协调和管理，所以需要CPU时间跟踪线程；

线程之间对共享资源的访问会相互影响，必须解决竞用共享资源的问题；

线程同步

并发与并行

并发:：一个CPU（采用时间片）同时执行多个任务。

并行:多个CPU同时执行多个任务。比如：多个人同时做不同的事。

多线程同步

多个线程同时读写一份资源时,可能会引起冲突.所以引入线程"同步"机制,即各线程间要先来后到.

同步就是排队+锁

几个线程之间要排队，一个个对共享资源进行操作，而不是同时进行操作；

为了保证数据在方法中被访问时的正确性，在访问时加入锁机制

确保一个时间点只有一个线程访问共享资源。可以给共享资源加一把锁，哪个线程获取了这把锁，才有权利访问该共享资源.

在Java代码中实现同步：

使用synchronized(同步监视器)关键字同步方法或代码块。 synchronized (同步监视器）{ 
    // 需要被同步的代码； 
}
//synchronized还可以放在方法声明中，表示整个方法,为同步方法。 例如：
public synchronized void show (String name){ 
    // 需要被同步的代码； 
}

同步监听器

同步监听器可以是任何对象,必须唯一,保证多个线程获得是同一个对象(锁).

同步监听器的执行过程

第一个线程访问，锁定同步监视器，执行其中代码.

第二个线程访问，发现同步监视器被锁定，无法访问.

第一个线程访问完毕，解锁同步监视器.

第二个线程访问，发现同步监视器没有锁，然后锁定并访问.

一个线程持有锁会导致其他所有需要此锁的线程挂起；在多线程竞争下，加锁，释放锁会导致比较多的上下文切换和调度延时，引起性能问题

Lock(锁)

从JDK 5.0开始，Java提供了更强大的线程同步机制-通过显式定义同步锁对象来实现同步。同步锁使用Lock对象充当。

java.util.concurrent.locks.Lock接口是控制多个线程对共享资源进行访问的工具。锁提供了对共享资源的独占访问，每次只能有一个线程对Lock对象加锁，线程开始访问共享资源之前应先获得Lock对象。

ReentrantLock类实现了Lock，它拥有与synchronized相同的并发性和内存语义，在实现线程安全的控制中，比较常用的是ReentrantLock，可以显式加锁、释放锁.

线程死锁

死锁:不同的线程分别占用对方需要的同步资源不放弃，都在等待对方放弃自己需要的同步资源，就形成了线程的死锁. 出现死锁后，不会出现异常，不会出现提示，只是所有的线程都处于阻塞状态，无法继续.

解决方式:设计时考虑清楚锁的顺序,尽量减少嵌套的加锁交互数量.

public class DieLock extends Thread{

    static Object objA = new Object();
    static Object objB = new Object();
    boolean flag;
    public DieLock(boolean flag){
        this.flag = flag;
    }

    @Override
    public void run(){
        if (flag){//线程一
            synchronized (objA){
                System.out.println("if objA");
                synchronized (objB){
                    System.out.println("if objB");
                }
            }
        }else {//线程二
            synchronized (objB){
                System.out.println("else B");
                synchronized (objA){
                    System.out.println("else A");
                }
            }
        }
    }
}

public class Test {
    public static void main(String[] args) {

        DieLock dieLock1 = new DieLock(true);
        DieLock dieLock2 = new DieLock(false);
        dieLock1.start();
        dieLock2.start();

    }
}

线程通信

概念

指的是多个线程通过消息传递实现相互牵制，相互调度，即线程间的相互作用.

涉及到的方法

wait一旦执行此方法，当前线程就进入阻塞状态，并释放同步监视器.

notify一旦执行此方法，就会唤醒被wait的一个线程。如果有多个线程被wait,就唤醒优先级高的那个.

notifyAll一旦执行此方法，就会唤醒所有被wait的线程.

说明

wait(),notify(),notifyAll()三个方法必须使用在同步代码块或同步方法中.

wait(),notify(),notifyAll()三个方法是定义在java.lang.Object类中.

实例

public class Counter {

    int  num = 0;
    /*
    生产者
     */
    public synchronized void add(){
        if (num==0){
            num++;
            System.out.println("生产了一个商品");
            this.notify();
        }else {
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    /*
    消费者
     */
    public synchronized void sub(){
        if (num>0) {
            num--;
            System.out.println("消费了一个商品");
            this.notify();
        }else {
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

public class CustomerThread extends Thread{

    Counter counter;

    public CustomerThread(Counter counter){
        this.counter = counter;
    }
    @Override
    public void run() {
        while (true) {
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            counter.sub();
        }
    }
}

public class ProductorThread extends Thread{

    Counter counter;

   public ProductorThread(Counter counter){
       this.counter = counter;
   }

    @Override
    public void run() {
        while (true) {
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            counter.add();
        }
    }
}

public class Test {

    public static void main(String[] args) {

        Counter c = new Counter();

        CustomerThread cu = new CustomerThread(c);
        ProductorThread p = new ProductorThread(c);

        cu.start();
        p.start();
    }
}

新增创建线程方式

实现Callable接口与使用Runnable相比，Callable功能更强大些

相比run（）方法，可以有返回值

方法可以抛出异常

支持泛型的返回值

需要借助FutureTask类，获取返回结果

接受任务

FutureTask<Integer> futureTask = new FutureTask(任务);

创建线程

Thread t = new Thread(futureTask); 

t.start(); 

Integer val = futureTask.get();//获得线程call方法的返回值

实例

import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

public class Test {

    public static void main(String[] args) {

        MyThread myThread = new MyThread();

        FutureTask<Integer> futureTask = new FutureTask(myThread);
        Thread t = new Thread(futureTask);
        t.start();

        try {
            Integer res = futureTask.get();
            System.out.println(res);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}

import java.util.concurrent.Callable;

public class MyThread implements Callable<Integer> {
    
    @Override
    public Integer call() throws Exception {
        int num = 0;
        num = 10;
        for (int i = 0; i < 10; i++) {
            num+=i;
        }
        return num;
    }
}
       } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}

import java.util.concurrent.Callable;

public class MyThread implements Callable<Integer> {
    
    @Override
    public Integer call() throws Exception {
        int num = 0;
        num = 10;
        for (int i = 0; i < 10; i++) {
            num+=i;
        }
        return num;
    }
}