多线程介绍（归纳）

最新推荐文章于 2024-09-10 23:16:00 发布
最新推荐文章于 2024-09-10 23:16:00 发布
阅读量631 收藏 1
点赞数 2
文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xasasaa/article/details/123776744
版权

线程和进程

进程就是计算机中正在进行的一个独立的应用程序，进程是一个动态的概念必须是进行状态，如果一个应用没有启动，那就不是进程
线程就是组成进程的基本单元，可以完成特定的功能，一个进程可以有多个线程组成

进程和线程的区别：

1、内存空间上的区别：
进程是有独有的内存空间，每个进程之间是相互独立的，互不影响
线程有共享的内存空间（也有私有空间）
2、安全性
进程是相互独立的，一个进程的奔溃不会影响到其他的进程，进程是安全
线程存在内存空间共享，一个线程的奔溃可能会影响到其他的线程的执行，线程的安全是不如进程

  • 关系：进程是相互独立的，一个进程下可以有一个或者多个线程

Java中是很少使用进程概念，但也可以使用
//Java中创建进程方式
Runtime runtime = Runtime.getRuntime();
Java启动线程
private native void start0();
native方法会调用底层操作系统支持，Java本身是没办法启动线程的，线程启动是需要依赖底层操作系统支持的，Java调用native方法，调用底层操作系统C++编写的动态函数库，有C++去操作底层启动线程。Java是间接的调用来启动线程

线程创建方式

● 继承thread类
● 实现Runable接口
● 实现Callable接口

实现Runable接口

Runable接口定义如下：

public interface Runnable {
     //抽象的run方法
    public abstract void run();
}

Runable接口中提供了一个抽象的run方法，实现RUnable接口实现run方法

Runnable实现方式

/**
 * 通过实现Runnable接口来进行run方法
 */
public class RunableDemo implements Runnable {
    @Override
    public void run() {
        System.out.println("线程名："+Thread.currentThread().getName()+"的线程在执行");
    }
}


RunableDemo runableDemo = new RunableDemo();
Thread thread = new Thread(runableDemo);
//当前才会创建子线程
thread.start();

Runnable实现类是任务，Thread类是线程对象，线程是用来执行任务的

实现Runnable的线程创建的步骤：

  1. 创建一个实现Runnable接口的实现类，并实现run方法
  2. 实例化Runnable接口实现类
  3. 创建Thread类实例，将实例化Runnable接口实现类作为参数传递
  4. 启动子线程，调用Thread类的实例的start

继承Thread类

Thread类的定义

  • public class Thread implements Runnable
    可以看出：Thread类实现了Runnable接口，即Thread类也是Runnable接口实现类，在Thread中业余run方法的实现`
    public void run() {
        if (target != null) {
            target.run();
        }
    }

Thread类中的run方法的实现中，target任务体不能为空，即调用run方法，需要通过Thread类来重写run方法

继承Thread类使用Demo

/**
 * 通过继承Thread类来重写run方法
 */
public class ThreadDemo extends Thread {
    @Override
    public void run() {
        System.out.println("ThreadDemo类 线程名："+
                Thread.currentThread().getName()+" 在执行");
    }
}


        //第二种：通过继承Thread类来创建线程
        ThreadDemo threadDemo = new ThreadDemo();
        threadDemo.start();

继承Thread类创建线程步骤：

  1. 创建类，继承Thread重写run方法
  2. 实例化当前创建的额Thread类的子类
  3. 启动子线程、调用start方法

实现Callable接口

Callable接口声明如下：

public interface Callable<V> {
    V call() throws Exception;
}

Callable接口提供了call方法，具有返回值，通过泛型来定义，该接口可以抛出异常

该接口的实现类是无法直接使用，需要借助于FutureTask类

public class FutureTask<V> implements RunnableFuture<V> {
    //该类能接口Callable实现类
    public FutureTask(Callable<V> callable) {
        if (callable == null)
            throw new NullPointerException();
        this.callable = callable;
        this.state = NEW;       // ensure visibility of callable
    }
}


RunnableFuture接口声明
public interface RunnableFuture<V> extends Runnable, Future<V> {
    void run();
}

FutureTask类是继承自Runnable接口，即FutureTask是Runable接口的实现类，而FutureTask类提供构造函数FutureTask(Callable callable)，可以接受Callable类型的任务
就可以借助FutureTask将Callable类型的实例转化为Runnable类型的实例

Callable接口实现的Demo

public class CallableDemo implements Callable {
    @Override
    public Object call() throws Exception {
        System.out.println("CallableDemo类 线程名："+Thread.currentThread().getName()+"在执行");
        return null;
    }
}

      //实例化Callable接口实现类
        CallableDemo callableDemo = new CallableDemo();
        //通过FutureTask可以将Callable实例转化为Runable实例
        FutureTask <String> futureTask = new FutureTask <String>(callableDemo);
        Thread thread1 = new Thread(futureTask);
        thread1.start();

实现Callable接口创建线程步骤

  1. 创建类，实现Callable接口，实现其提供的call方法
  2. 创建Callable实例
  3. 创建FutureTask实例，将Callable实例作为参数传入
  4. 创建Thread实例，将FutureTask实例作为参数传递（当做Runable实例）
  5. 启动子线程，调用Thread类的Start方法
  6. 线程的状态及状态转换

线程状态

JDK中提供的线程状态在Thread类中的一个子枚举类
public enum State {
NEW,
RUNNABLE,
BLOCKED,
WAITING,
TIMED_WAITING,
TERMINATED;
}

  • 新建状态(NEW)
    使用new语句创建的线程处于新建状态(new Thread),仅仅在堆上分配了内存
  • 就绪状态(Runnable)
    当线程创建后，其他线程调用start方法，该线程就进入到就绪状态，JVM就会为创建方法调用栈和程序计数器，处于这个状态的线程位于可运行的池中，等待获取CPU的使用权
    其他处于则塞状态解除阻塞之后也会进入就绪状态
  • 运行状态(Running)
    处于这个状态的线程占用CPU，执行程序代码，只有处于就绪状态的额线程才会有机会转到运行状态
  • 阻塞状态（Blocked）
    当线程由于缺少响应的资源而导致程序无法继续执行，就会从运行状态进入到阻塞状态比 如：锁资源，IO资源
  • 等待状态(Waiting)
    当线程调用了wait方法就会进入到waiting状态，该状态只有notify等操作才能唤醒线程进入下一个状态
  • 睡眠状态(Time_Waiting)
    如果线程执行了sleep(long)/join(long)/wait(long)，会触发线程进入到Time_waiting状态，只有到达设定的时间，才会脱离阻塞状态
  • 终止状态(Terainated)
    当线程退出run方法，就进入到终止状态，该线程结束生命周期

线程状态转化
在这里插入图片描述
一个线程的生命周期需要状态：New、Runnable、Running、Terminated状态
线程在需要响应资源时，就会进入到阻塞状态，阻塞状态包含Waiting、Blocked、Time_waiting状态

线程方法

start():启动线程
start方法作用是启动一个新线程执行，start需要首先调用，而且不能不能重复调用
start方法会使线程从新建状态进入到就绪状态

public synchronized void start() {
        if (threadStatus != 0)
            throw new IllegalThreadStateException();

        group.add(this);

        boolean started = false;
        try {
            start0();
            started = true;
        } finally {
            try {
                if (!started) {
                    group.threadStartFailed(this);
                }
            } catch (Throwable ignore) {
            }
        }
    }

    private native void start0();

start方法启动子线程是通过调用系统提供的方式来启动线程
run()：子线程的执行体
run方法和普通成员方法一样，可以重复调用
单独调用run方法,会在当前线程中执行run方法，并不会启动新线程
yield():线程让步
yield方法暂停当前线程的执行，并让步于其他同优先级的线程，让其他线程先执行

特点：

  1. yield方法的让步，能让正在执行的线程由“运行状态”进入到“就绪状态”，等待调度执行
  2. yield仅仅是让出CPU资源，让给谁，是有系统决定的，系统会让其他相同优先级或者是更高优先级的线程来获取执行权，要是没有更高优先级的线程，会继续执行原来的线程

public static native void yield();

是定义在Thread类中的静态方法
join():线程合并
作用：
暂停当前线程的执行，等待子线程执行，也叫做线程合并，join方法做的事情就是讲并行执行的线程合并为串行执行
例如：如果在a线程中调用b线程的join方法即b.join方法，则会让b线程先执行，直到b线程执行结束，a线程才能继续执行

方法介绍：
join方法是在Thread类中，可以被中断掉
t.join()是允许t线程插队到当前线程前面，等t线程执行完成再执行当前线程
t.join(millis)是允许t线程插队到当前线程前面，等t线程执行且最长等待millis毫秒再执行当前线程
t.join(millis,nanos)和t.join(millis)类似，给定了有限时间等待，只是提供了一个纳秒级精度

public final synchronized void join(long millis) throws InterruptedException {
        long base = System.currentTimeMillis();
        long now = 0;

        if (millis < 0) {
            throw new IllegalArgumentException("timeout value is negative");
        }

        if (millis == 0) {
            //特殊标识，标识一致阻塞
            while (isAlive()) {
                wait(0);
            }
        } else {
            //millis大于0，会阻塞到最多millis时间
            while (isAlive()) {
                long delay = millis - now;
                if (delay <= 0) {
                    break;
                }
                wait(delay);
                now = System.currentTimeMillis() - base;
            }
        }
    }

    public final synchronized void join(long millis, int nanos)throws InterruptedException {
        if (millis < 0) {throw new IllegalArgumentException("timeout value is negative");}
        if (nanos < 0 || nanos > 999999) {throw new IllegalArgumentException("nanosecond timeout value out of range");}

        if (nanos >= 500000 || (nanos != 0 && millis == 0)) {
            millis++;
        }

        join(millis);
    }


    public final void join() throws InterruptedException {
        join(0);
    }

方法特点：

  1. 当前线程a调用b.join(),b线程会开始执行，a线程进入到阻塞状态
  2. join方法hi被中断，如果有Interrupt方法会导致当前阻塞提前结束，会抛出InterruptedException
    sleep()：线程休眠
    会是当前线程进入休眠

特点：在sleep期间，线程运行状态从运行进入到阻塞状态，会让出CPU的执行权，当线程被重新唤醒时，会由阻塞状态进入到就绪状态，等待CPU的使用权

方法介绍：
sleep方法主要有两个，sleep(long millis) 和sleep(long millis, int nanos)两个方法功能类似，后一个方法提供更高精度的纳秒级控制
sleep方法是Thread里提供的静态方法，当前的方法也是可以抛出InterruptedException，可以被Interrupt中断掉

public static native void sleep(long millis) throws InterruptedException;

    public static void sleep(long millis, int nanos)throws InterruptedException {
        if (millis < 0) {throw new IllegalArgumentException("timeout value is negative");}

        if (nanos < 0 || nanos > 999999) {throw new IllegalArgumentException("nanosecond timeout value out of range");}

        if (nanos >= 500000 || (nanos != 0 && millis == 0)) {
            millis++;
        }

        sleep(millis);
    }

Interrupt():中断线程
Interrupt方法是中断当前线程，终止处于阻塞状态的线程

Interrupt方法在Thread类中，是一个普通方法，可以都对象来调用

    public void interrupt() {
        if (this != Thread.currentThread())
            checkAccess();

        synchronized (blockerLock) {
            Interruptible b = blocker;
            if (b != null) {
                interrupt0();           // Just to set the interrupt flag
                b.interrupt(this);
                return;
            }
        }
        interrupt0();
    }
private native void interrupt0();

interrupt特点
interrupt方法调用仅仅修改了一个中断标志
如果当前线程是可中断的状态(调用了sleep、join、wait等方法导致线程进入阻塞状态)在其他线程中调用interrupt方法，会立即抛出一个InterruptedException，来停止掉中断
如果当前处于运行状态，调用interrupt方法，线程会继续执行，直到发生sleep、join、wait等方法的调用，才会进入阻塞

deamon：守护线程
守护线程存在两个方法
setDaemon(boolean on) 设置守护线程，参数是true和false，true表明设置为守护线程， false，设置为非守护线程 ，默认是false
boolean isDaemon()判断是否守护线程，返回Boolean类型

守护线程：Java线程有两种，一种是守护线程，一种是用户线程
用户线程一般用户执行用户级任务，一般创建的线程都是用户线程
守护线程也叫做“后台线程”服务于用户线程，一般就是用来执行后台任务，例如：垃圾回收是专门线程来处理的，负责垃圾回收的线程就是守护线程

守护线程的生命周期：
守护线程的生命周期依赖于用户线程，当用户线程存在，守护线程就会存在，当用户线程不存在，那么守护线程也就会随之消亡
Priority：线程优先级
线程优先级，就是用来指导线程执行的优先权

方法介绍：
int getPriority()：获取线程的优先级setPriority(int newPriority)，设置当前线程的优先级，newPriority必须是1-10之间的额整数，否则会抛出异常
优先级范围：
public final static int MIN_PRIORITY = 1;
public final static int NORM_PRIORITY = 5;
public final static int MAX_PRIORITY = 10;
设置Java线程的优先级，最小值为1，默认值是5，最大值是10

方法特点：

  1. 线程的优先级并不绝对，所控制的是执行的机会，优先级高的线程执行的概率是比较大，而优先级低的线程也并不是没有机会，只是执行的概率会低一些
  2. 优先级工10个优先级，分别为1-10，数值越大，表名优先级越高，普通的线程，优先级是5
  3. 线程的优先级是用来指导JVM层面优先那个线程执行，最终执行顺序需要操作系统来指定
  4. 注意；代码最好不要依赖于优先级线程，有可能会造成问题，java中给定的优先级并不一定严格按照给定优先级执行
夏木一秋
关注
多线程的详细介绍
编程人生
04-20 582
多线程全面详解总结 一、多线程是什么？为什么要用多线程？ 　　介绍多线程之前要介绍线程，介绍线程则离不开进程。 　　首先 进程 ：是一个正在执行中的程序，每一个进程执行都有一个执行顺序，该顺序是一个执行路径，或者叫一个控制单元； 　　线程：就是进程中的一个独立控制单元，线程在控制着进程的执行。一个进程中至少有一个进程。 多线程：一个进程中不只有一个线程。 　 为什么...
Java单利模式与多线程总结归纳
09-02
在多线程环境中，如果多个线程同时访问`getInstance()`方法，可能导致多个线程各自创建单例对象，从而违反单例模式的原则。为了使懒汉式单例在多线程环境下正确工作，通常需要添加synchronized关键字来同步`...
多线程简介（全）
weixin_30394333的博客
08-04 139
线程实现方式 并发与并行 并发：指两或多个事件在同一个时间段内发生 并行：指两或多个事件在同一个时刻发生（同时发生） 进程的概念 内存：所有的应用程序都需要进入到内存中执行 临时存储RAM 硬盘：永久存储ROM 进入到内存的程序叫进程 任务管理器-->结束进程 那么就把进程从内存中清除了 线程的概念 点击一个应用程序的功能执行，就会开启一条应用...
第四章 多线程
最新发布
weixin_62008675的博客
09-10 1411
线程A正在使用sleep()暂停着: Thread.sleep(100000)，如果要取消它的等待状态,可以在正在执行的线程里(比如这里是B)调用a.interrupt()［a是线程A对应到的Thread实例］，令线程A放弃睡眠操作。线程在进入等待区,会把锁定解除,当对等待中的线程调用interrupt()时，会先重新获取锁定，再抛出异常。在获取锁定之前，是无法抛出异常的。当线程以join()等待其他线程结束时，当它被调用interrupt()，它与sleep()时一样，会马上跳到catch块里.。
多线程(一) 多线程介绍及基本使用
淡淡的倔强的博客
03-26 2197
<一>多线程介绍  程序(program)是为完成特定任务、用某种语言编写的一组指令的集合。即指一段静态的代码，静态对象。   进程(process)是程序的一次执行过程，或是正在运行的一个程序。动态过程：有它自身的产生、存在和消亡的过程。   如：运行中的QQ，运行中的MP3播放器。   程序是静态的，进程是动态的。   线程(thread)，进程可进一步细化为线程，是一个程序内部的一条执
多线程简介
半雨微凉
08-19 268
简介 在windows操作系统中，所有程序的功能都是由每个程序中的多个线程共同完成的。所以，线程才是计算机真正意义上的执行者。而从线程执行的数目而言，线程可以分为单线程和多线程，如果从执行效率而言，多线程比单线程执行效率高很多。 进程 进程是指当前可执行文件运行时，系统所创建的内核对象。比如用户可以在任务管理器中查看正在运行的所有的进程。 可执行程序（.exe）可以包括一个或多个进程，每个...
1.介绍多线程
dilinying2838的博客
01-26 118
多线程 多线程是用来做什么的，我想举一个例子简单说明一下。 我正在工作，但是到中午了，饿了，但是去做饭就必须停下手中的工作。 而做饭又是一件非常耗时的事情，在做饭的时候，工作就处于停滞状态。 这就是串行程序的执行方式。 工作 ------> 停止工作 ------> 做饭 而随着社会的发展，外卖行业的发展，我们可以打电话订外卖。 做饭本身交给了别人，解放了自己的时间，所以工作...
pb多线程[归纳].pdf
10-19
本文将重点介绍如何在PB中使用SharedObject系列函数来实现多线程操作。 首先，`SharedObjectRegister`函数用于初始化共享对象并创建一个新的线程。在示例中，`SharedObjectRegister ("ccuo_thread" , "thread1")`...
C++多线程总结[归纳].pdf
10-19
本文档对C++多线程编程进行了总结，介绍了三种创建线程的方法：CreateThread函数、AfxBeginThread函数和_beginthread()/_beginthreadex()函数，同时对线程的管理和终止进行了详细的讲解。 CreateThread函数 ...
Java 多线程学习总结归纳（附代码）
01-09
Java多线程是Java编程中的核心概念，它允许程序同时执行多个任务，从而提升系统效率。在Java中，实现多线程主要有两种方式：继承Thread类和实现Runnable接口。下面是对Java多线程学习的详细解析。 1. **多线程概述*...
Boost库多线程[归纳].pdf
10-19
Boost库多线程[归纳].pdf
[转]关于iOS多线程，你看我就够了
lcvs的专栏
07-31 845
原文地址：http://www.jianshu.com/p/0b0d9b1f1f19 在这篇文章中，我将为你整理一下 iOS 开发中几种多线程方案，以及其使用方法和注意事项。当然也会给出几种多线程的案例，在实际使用中感受它们的区别。还有一点需要说明的是，这篇文章将会使用 Swift 和 Objective-c 两种语言讲解，双语幼儿园。OK，let's begin! 概述
多线程的介绍
yzjcsdn的博客
02-01 417
1、多线程运行的原理 多线程能够实现主要是 CPU在线程中做时间片的切换。 其实真正电脑中的程序的运行不是同时在运行的。 CPU负责程序的运行，而CPU在运行程序的过程中某个时刻点上，它其实只能运行一个程序,而不是多个程序。 而CPU它可以在多个程序之间进行高速的切换。而切换频率和速度太快，导致人的肉眼看不到。 每个程序就是进程， 而每个进程中会有多个线程，而CP
多线程 之 线程简介
weixin_43247990的博客
10-25 333
什么是进程？ 所有运行中的程序通常对应一个进程。当一个程序进入内存运行时，就会变成一个进程。 进程是出于运行过程中的程序，并且具有一定的独立功能。 进程是系统进行资源分配和调度的独立单位。 进程包含散打特征： 1.独立性。进程是系统中独立存在的实体，拥有自己独立的资源，每一个进程都拥有自的私有的地址空间，在没有经过进程本身允许的情况下，一个用户进程不可以直接访问其他进程的地址空间。 2.动态性。进...
Java基础之多线程(一)--概述、同步、死锁、单例模式
枫叶的专栏
06-30 674
概述： /* 进程：是一个正在执行中的程序。 每一个进程执行都有一个执行顺序。该顺序是一个执行路径，或者叫一个控制单元。 线程：就是进程中的一个独立的控制单元。 线程在控制着进程的执行。 一个进程中至少有一个线程。 Java VM 启动的时候会有一个进程java.exe. 该进程中至少一个线程负责java程序的执行。 而且这个线程运行的代码存在于main方法中。 该线程称之
Java单例模式与多线程深度解析
"Java单例模式与多线程总结归纳" 在Java编程中，单例模式是一种常用的设计模式，它的核心在于确保一个类只有一个实例，并提供一个全局访问点。单例模式的应用广泛，如线程池、缓存、日志系统、对话框等，其目的是...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值