【Java-多线程】

DHH.

已于 2023-07-02 21:01:39 修改

阅读量31

点赞数

分类专栏：多线程文章标签： java

于 2023-07-02 20:58:30 首次发布

本文链接：https://blog.csdn.net/qq_61513126/article/details/131504325

版权

多线程专栏收录该内容

1 篇文章 0 订阅

订阅专栏

线程

程序，进程，线程
多线程

程序，进程，线程

● 程序(program)是为完成特定任务、用某种语言编写的一组指令的集合。即指一
段静态的代码.
● 进程((process)就是正在执行的程序,从Windows角度讲，进程是操作系统进行
资源分配的最小单位.
● 线程(thread)进程可进一步细化为线程，是一个进程内部的最小执行单元，是操
作系统进行任务调度的最小单元，隶属于进程.
一个进程可以包含多个进程，一个进程只属于一个线程，线程不能脱离进程而独立运行。
在主线程中可以启动并创建其他的线程。
一个进程内的所有进程共享该进程的内存资源

创建线程

继承Thread类的方式

扩展Thread类，重写其中run（）方法
Thread类中的run方法本身并不执行任何操作，如果我们重写了run方法，当线程启动时，它将执行
run方法。

package ThreadDemo.Demo;

public class Test {
    public static void main(String[] args) {
        //调用
        Mythread mythread = new Mythread();
        Thread thread=new Thread(mythread);
        thread.start();

        for (int i = 0; i < 1000; i++) {
            System.out.println("main"+i);
        }
    }
}
class Mythread implements Runnable{//定义
    @Override
    public void run() {
        for (int i = 0; i < 1000; i++) {
            System.out.println("mythread"+i);
        }
    }
}

实现Runnable接口的方式

实现Runnable接口的方式
java.lang.Runnable接口中仅仅只有一个抽象方法：public void run()
通过实现Runnable接口的方式来实现线程，只需要实现其中的run方法即
可；
Runnable接口的存在主要是为了解决Java中不允许多继承的问题。
调用

package ThreadDemo.Demo2;

public class Test {
    public static void main(String[] args) {
        Mythread mythread=  new Mythread();
        Thread thread = new Thread(mythread,"mythread");
        thread.start();
        System.out.println(Thread.currentThread().getId());
        System.out.println(Thread.currentThread().getName());
    }
}

定义

package ThreadDemo.Demo2;

public class Mythread implements Runnable{
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getId());
        System.out.println(Thread.currentThread().getName());
    }

}

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

区别：
继承Thread：线程代码存放Thread子类的run方法。
实现Runnable: 线程代码存在接口的子类的run方法。
实现Runnable的好处：

避免了单继承的局限性。
多个线程可以共享一个接口实现类的对象，非常适合多个相同的线程来处理同一份资源

线程的优先级

计算机只有一个CPU，各个线程轮流获得cpu使用权，才能执行任务。
优先级高的线程有获得更多cpu的机会。
优先级用整数表示，取值范围是1~10，一般情况下，线程的默认优先级
都是5，但是也可以通过setPriority和getPriority方法来设置或返回优先级；

● 调度策略
● 时间片
● 抢占式：高优先级的线程抢占CPU
●Java的调度方法
● 同优先级线程组成先进先出队列，使用时间片策略
● 对高优先级，使用优先调度的抢占式策略

Thread类有如下3个静态常量来表示优先级
● MAX_PRIORITY：取值为10，表示最高优先级。
● MIN_PRIORITY：取值为1，表示最底优先级。
● NORM_PRIORITY：取值为5，表示默认的优先级。

线程状态

线程在它的生命周期中会处于不同的状态：
在这里插入图片描述
线程的状态：
● 新建：当一个Thread类或其子类的对象被声明并创建时，新生的线程对
象处于新建状态
● 就绪：处于新建状态的线程被start（）后，将进入线程队列等待CPU时
间片，此时它已具备了运行的条件，只是没分配到CPU资源
● 运行：当就绪的线程被调度并获得CPU资源时，便进入运行状态，run
（）方法定义了线程的操作和功能
● 阻塞：在某种特殊情况下，被人为挂起或执行输入输出操作时，让出
CPU并临时中止自己的执行，进入阻塞状态
● 死亡：线程完成了它的全部工作或线程被提前强制性地中止或出现异常
导致结束

守护线程

Java中的线程分为两类：用户线程和守护线程
任何一个守护线程都是整个JVM中所有非守护线程的保姆,只要当前JVM实例中尚存在
任何一个非守护线程没有结束，守护线程就全部工作；
只有当最后一个非守护线程结束时，守护线程随着JVM一同结束工作。
守护线程的作用是为其他线程的运行提供便利服务，守护线程最典型的应用就是 GC
(垃圾回收器)，它就是一个很称职的守护者。
用户线程和守护线程唯一的不同之处： 虚拟机的离开：如果
用户线程已经全部退出运行了，只剩下守护线程存在了，虚拟机也就退出了。因为没
有了被守护者，守护线程也就没有工作可做了，也就没有继续运行程序的必要了.
设置守护线程: setDaemon(boolean on)
注意:设置线程为守护线程必须在启动线程之前，否则会跑出一个
IllegalThreadStateException异常。

package ThreadDemo.Demo4;
import java.util.Random;

public class Test1 {

    public static void main(String[] args) throws InterruptedException {
        // 守护线程在主线程操作完成后就会自动退出，所以不适合进行读写操作
        DaemonRunnable runnable = new DaemonRunnable();
        Thread thread = new Thread(runnable);
        thread.setDaemon(true);
        thread.start();
        for (int i = 0; i < 10000; i++) {
            System.out.println(i);
        }

    }

}
class DaemonRunnable implements Runnable{
    @Override
    public void run() {
        int i=0;
        while (true){
            System.out.println("DaemonRunnable"+":"+i++);
        }
    }
}

多线程

概念

概念
多线程是指程序中包含多个执行单元，即在一个程序中可以同时运行多
个不同的线程来执行不同的任务，也就是说允许单个程序创建多个并行
执行的线程来完成各自的任务。
何时需要多线程
● 程序需要同时执行两个或多个任务。
● 程序需要实现一些需要等待的任务时，如用户输入、文件读写操作、
网络操作、搜索等。
多线程的优缺点

优点：
提高程序的响应
.提高CPU的利用率.
改善程序结构,将复杂任务分为多个线程,独立运行.
缺点：
**线程也是程序，所以线程需要占用内存，**线程越多占用内存也越多；
多线程需要协调和管理，所以需要CPU时间跟踪线程；
线程之间对共享资源的访问会相互影响；

线程同步

多线程同步：多个线程同时读写同一份共享资源时，可能会引起冲突。所以引入线程“同步”机制，
即各线程间要有先来后到；
同步就是排队+锁：
● 几个线程之间要排队，一个个对共享资源进行操作，而不是同时进行操作；
● 为了保证数据在方法中被访问时的正确性，在访问时加入锁机制
例：
模拟卖票
两个窗口分别售票,票数为10张
分别使用继承Thread和实现Runnable两种方式实现
继承Thread

package ThreadDemo.TicketThread;

public class TicketDemo extends Thread {
   static int num=10;
    @Override
    public void run() {
        while (true){
            if(num==0){

                break;
            }
            try {
                Thread.sleep(200);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            ps();
        }
    }
    public static synchronized void ps(){
        if(num>0){
            System.out.println(Thread.currentThread().getName()+"："+num);
            num--;
        }
    }
}

调用

package ThreadDemo.TicketThread;

public class Test {
    public static void main(String[] args) {
        TicketDemo ticketDemo=new TicketDemo();
        ticketDemo.setName("出口1");
        ticketDemo.start();
        TicketDemo ticketDemo1=new TicketDemo();
        ticketDemo1.setName("出口2");
        ticketDemo1.start();
    }
}

在这里插入图片描述

Runnable的实现

package ThreadDemo.TicketThread2;

public class TicketRun implements Runnable{
     int i=10;
    @Override
    public void run() {
        while (true){
            if(i==0){
                break;
            }
            ps();
        }
    }
    public synchronized void ps(){
        if(i>0){
            System.out.println(Thread.currentThread().getName()+":"+i);
            i--;
        }
    }
}

调用

package ThreadDemo.TicketThread2;

import ThreadDemo.TicketThread.TicketDemo;

public class Test {
    public static void main(String[] args) {
        TicketRun run=new TicketRun();
        Thread thread=new Thread(run,"窗口1");
        thread.start();
        Thread thread1=new Thread(run,"窗口2");
        thread1.start();
    }
}

确保一个时间点只有一个线程访问共享资源。可以给共享资源加一把锁，哪个
线程获取了这把锁，才有权利访问该共享资源。
使用synchronized关键字同步方法或代码块

同步锁

同步锁
同步锁可以是任何对象,必须唯一,保证多个线程获得是同一个对象(用
来充当锁标记). 同步执行过程

第一个线程访问，锁定同步对象，执行其中代码.
第二个线程访问，发现同步对象被锁定，无法访问.
第一个线程访问完毕，解锁同步对象.
第二个线程访问，发现同步对象没有锁，然后锁定并访问.

Lock锁

package ThreadDemo.TicketThread3;
import java.util.concurrent.locks.ReentrantLock;
public class Ticketlock implements Runnable{
    int num=1000;
    static ReentrantLock lock=new ReentrantLock();
    /*
        Reentrantlock 实现lock接口，所以称为lock锁
        是一种java代码层面的控制实现；
        synchronized是关键字，依靠底层编译后的指令实现。
        reentrantlock 只能对某一段代码块加锁
        synchronized 可以对代码块和方法加锁。
        加锁方式不同
        reentrantlock需要手动的加锁，释放锁
        synchronized 隐式加锁，自动释放锁
    */
    @Override
    public void run() {
        while (true){
            lock.lock();
            try {
                if(num==0){
                    break;
                }
                if(num>0){
                    System.out.println(Thread.currentThread().getName()+":"+num);
                    num--;
                }
            }finally{
                lock.unlock();
            }
        }
    }
}

package ThreadDemo.TicketThread3;

import ThreadDemo.TicketThread2.TicketRun;

public class Test {
    public static void main(String[] args) {
        Ticketlock ticketlock=new Ticketlock();
        Thread thread=new Thread(ticketlock,"窗口1");
        thread.start();
        Thread thread1=new Thread(ticketlock,"窗口2");
        thread1.start();
    }
}

死锁

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

线程通信

线程通讯指的是多个线程通过相互牵制，相互调度，即线程间的相互作用。涉及三个方法：
.wait一旦执行此方法，当前线程就进入阻塞状态，并释放同步监视器。
.notify一旦执行此方法，就会唤醒被wait的一个线程。如果有多个线程被wait，
就唤醒优先级高的那个。
.notifyAll一旦执行此方法，就会唤醒所有被wait的线程。
注意：
.wait（），notify（），notifyAll（）三个方法必须使用在同步代码块或同步方
法中。

package ThreadDemo.Demo5;

// 两个线程交替打印1-100之间的数字
public class WaitlockThread extends Thread{
    static Object object=new Object();
    static int num=1;
/*
    wait()是Object类中定义的方法，必须是使用同步对象来进行调用，是让线程等待，必须通过唤醒才能执行
    notify（）是object类中定义的方法，必须是使用同步对象来进行调用，可以唤醒其他被wait的线程
    notifyAll（）是object类中定义的方法，必须是使用同步对象来进行调用，用来唤醒所有被等待的线程4
 */
    @Override
    public void run() {
        while(num<=100){
                synchronized (object){
                    object.notify();//唤醒等待的线程
                    System.out.println(Thread.currentThread().getName()+":"+num);
                    num++;
                    try {
                        object.wait();//让线程等待，释放锁，等待的线程不能自己醒来，必须让其他线程唤醒
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                if(num==100){
                break;
            }
        }
    }
}

package ThreadDemo.Demo5;

public class Test {
    public static void main(String[] args) {
        WaitlockThread waitlockThread=new WaitlockThread();
        WaitlockThread waitlockThread1=new WaitlockThread();
        waitlockThread.setName("张乃号");
        waitlockThread1.setName("咒奶身");
        waitlockThread.start();
        waitlockThread1.start();
    }
}

新增创建线程方式

实现Callable接口与使用Runnable相比，Callable功能更强大些. • 相比run（）方法，可以有返回值
• 方法可以抛出异常
• 支持泛型的返回值
• 需要借助FutureTask类，获取返回结果
接收任务
FutureTask futureTask = new FutureTask(任务);
创建线程
Thread t = new Thread(futureTask);
t.start();
Integer val = futureTask.get();获得线程call方法的返回值

package ThreadDemo.Demo7;

import java.util.concurrent.Callable;

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

package ThreadDemo.Demo7;

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

public class Test {
    public static void main(String[] args) {
        CallableDemo callableDemo=new CallableDemo();
        FutureTask<Integer> futureTask=new FutureTask(callableDemo);
        Thread thread=new Thread(futureTask);
        thread.start();
        try {
            Integer sum= futureTask.get();
            System.out.println(sum);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }

    }
}