有关线程的相关知识（上）

最新推荐文章于 2023-08-13 10:02:03 发布
最新推荐文章于 2023-08-13 10:02:03 发布
阅读量2.5w 收藏
点赞数 4
分类专栏： java Java学习之旅 文章标签： java 线程 并发
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hai_qing_xu_kong/article/details/70215452
版权

转载请标明出处:
http://blog.csdn.net/hai_qing_xu_kong/article/details/70215452
本文出自：【顾林海的博客】

前言

一系列任务的同时运行称之为并发，可以认为是多个任务交替执行，并且多个任务之间有可能还是串行的，与并发相关的另一个概念是并行，并行是真正意义上的“同时执行”。

线程的两种创建方式

我们在Java中创建线程可以通过以下两种方式来创建：

  1. 继承Thread类，并且覆盖run()方法。
  2. 创建一个实现Runnable接口的类，使用带参数的Thread构造器来创建Thread对象。

接下来看看以下程序：

public class MyThread extends Thread{

    private int i;

    public MyThread(int i){
        this.i=i;
    }

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+" : "+i);
    }

}

创建了一个继承Thread类的MyThread子类，内部声明了一个名为i的私有int属性，通过构造器来初始化i的值，接着重写run方法，这个方法用来执行我们创建的线程的指令，在run()方法中输出当前线程名和i的值。下面是主类：

public class Client {

    public static void main(String[] args) {
        MyThread thread;
        for(int i=0;i<10;i++){
            thread=new MyThread(i);
            thread.setName("Thread "+i);
            thread.start();
        }
    }

}

我们在主类中通过for循环创建了十个MyThread对象，并给这十个Thread对象设置名字。看看输出结果吧：

Thread 0 : 0
Thread 4 : 4
Thread 3 : 3
Thread 5 : 5
Thread 6 : 6
Thread 2 : 2
Thread 1 : 1
Thread 7 : 7
Thread 8 : 8
Thread 9 : 9

从输出结果来看，代码的运行结果与代码执行顺序或调用顺序是无关的。线程是一个子任务， CPU以不确定的方式，或者说是以随机时间来调用线程的run方法，所以会出现运行结果的顺序与执行顺序不一致的问题。

使用第二种方式实现Runnable接口来实现上面的代码：

public class MyRunnable implements Runnable{

    private int i;

    public MyRunnable(int i){
        this.i=i;
    }

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+" : "+i);
    }

}
public class Client {

    public static void main(String[] args) {
        for(int i=0;i<10;i++){
            MyRunnable runable=new MyRunnable(i);
            Thread thread=new Thread(runable);
            thread.setName("Thread "+i);
            thread.start();
        }
    }

}

最后运行的结果与上面的一样，有可能输出顺序不同。

当然，我们在创建线程时也可以通过Thread类保存的一些属性来标示线程，比如通过getId()方法来获取线程的唯一标识符、通过getName()方法获取线程的名字、以及通过getPriority()方法获取线程的优先级。线程的优先级从1到10，其中1是最低优先级，10是最高优先级。

线程的状态

线程的状态可以通过getState()方法来获取，线程状态有6种：new、runnable、blocked、waiting、time waiting或者terminated。

new状态表示刚刚创建的线程，这种线程还没开始执行。当线程的start()方法被调用时，表示线程开始执行，这时处于runnable状态，如果线程在执行过程中遇到了synchronized同步块，就会进入blocked阻塞状态，这时线程就会暂停执行，直到获得请求的锁。waiting和time waiting都表示等待状态，区别是waiting会进入一个无时间限制的等待，time waiting会进行一个有时间的等待。当线程执行完毕，就会进入terminated状态，表示结束。下面我们用程序来模拟这几种状态。

public class MyRunnable implements Runnable{

    @Override
    public void run() {
        System.out.println("Thread state : "+Thread.currentThread().getState());
    }

}

创建实现Runnable接口的MyRunnable类，并在run方法中，输出当前线程的状态。

public class Client {

    public static void main(String[] args) {
            MyRunnable runable=new MyRunnable();
            Thread thread=new Thread(runable);

            System.out.println("Thread state : "+thread.getState());

            thread.start();
    }

}

我们的主类先是创建MyRunnable对象，并以参数形式创建 Thread对象，随后在start之前获取线程状态。

我们看看输出结果：

Thread state : NEW
Thread state : RUNNABLE

很显然，在线程被构建时，但还没有调用start方法，时处于new状态，随后执行start方法，并在线程执行过程中输出该线程的状态为runnable状态。

下面是waiting和time waiting两种状态。

public class MyRunnable implements Runnable{

    @Override
    public void run() {
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        System.out.println("Thread state : "+Thread.currentThread().getState());
    }

}

我们在run方法中通过Thread类的静态方法sleep睡眠2秒，随后输出该线程状态。

public class Client {

    public static void main(String[] args) {

            MyRunnable runable=new MyRunnable();
            Thread thread=new Thread(runable);
            thread.start();
            try {
                Thread.sleep(1000);
                System.out.println("Thread state : "+thread.getState());
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }


    }

}

在主类中，创建Thread对象，并启动线程，接着睡眠1秒后输出，thread对象的状态，当睡眠一秒后，thread对象还是处于睡眠状态，由此输出结果：

Thread state : TIMED_WAITING
Thread state : RUNNABLE

线程进入等待状态，进入该状态表示当前线程需要等待其他线程做出一些特定动作（通知或中断）。

我们在上面的主类中多加一段代码：

public class Client {

    public static void main(String[] args) {

            MyRunnable runable=new MyRunnable();
            Thread thread=new Thread(runable);
            thread.start();
            try {
                Thread.sleep(1000);
                System.out.println("Thread state : "+thread.getState());
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }

            try {
                Thread.sleep(3000);
                System.out.println("Thread state : "+thread.getState());
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }

    }

}

在休眠3秒后输出thread对象的状态，这时创建的线程已经执行完毕，我们可以通过运行结果来查看：

Thread state : TIMED_WAITING
Thread state : RUNNABLE
Thread state : TERMINATED

阻塞状态，表示线程阻塞于锁:

public class MyRunnable implements Runnable{

    @Override
    public void run() {
        synchronized (MyRunnable.class) {
            try {
                Thread.sleep(3000);
                System.out.println(Thread.currentThread().getName()+" state : "+Thread.currentThread().getState());
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }

    }

}

创建实现Runnable接口的类，并实现run方法，在run方法中通过synchronized同步这段代码块。

public class Client {

    public static void main(String[] args) {

            MyRunnable runable=new MyRunnable();
            Thread thread1=new Thread(runable,"Thread-1");
            Thread thread2=new Thread(runable,"Thread-2");
            thread1.start();
            thread2.start();

            try {
                thread1.sleep(1000);
                System.out.println(thread2.getName()+" state :"+thread2.getState());
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }

    }

}

在主类中创建了两个Thread对象，当两个线程执行start方法后，睡眠1秒，输出thread2的状态，这时，thread1睡眠3秒才会释放锁，因此，thread2因为同步机制被挂起，直到thread1线程离开synchronized同步块（临界区）。运行结果：

Thread-2 state :BLOCKED
Thread-1 state : RUNNABLE
Thread-2 state : RUNNABLE
IT界的吉祥物
关注
专栏目录
Java多线程相关知识总结
03-15
### Java多线程相关知识总结 #### 一、基本概念 多线程是现代编程语言中一项非常重要的特性，尤其在Java这样的高级语言中更是如此。简单来说，**多线程**指的是在一个程序中能够同时运行多个不同的执行路径。下面...
线程相关知识总结
雅俗共赏的博客
01-13 815
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录前言一、线程的相关概念1、并发和并行2、线程和进程3、守护线程4、线程的状态及线程状体转换5、wait、sleep、yield和join的区别6、线程如何创建7、使用多线程带来的问题8、线程死锁的四个条件9、线程阻塞会造成进程阻塞吗10、线程间通信的几种方式二、线程池相关1、四种常用线程池2、创建线程池的方式2、线程和进程3、阻塞队列4、如何合理设置线程池的大小5、线程池如何关闭6、线程池submit和execute的区别7、线程池
线程基础知识点
06-20 719
一、概念 进程并不执行任务，只是为线程提供空间和资源，线程才是执行任务的实体。
关于线程知识详细总结
freeherotoday的博客
11-08 915
是为了建立程序单独的执行路径，让多部分代码实现同时执行——并发执行。
线程详解大全
qq_56454895的博客
03-13 3346
线程池是一种利用池化技术思想来实现的线程管理技术，主要是为了复用线程、便利地管理线程和任务、并将线程的创建和任务的执行解耦开来。我们可以创建线程池来复用已经创建的线程来降低频繁创建和销毁线程所带来的资源消耗。在JAVA中主要是使用ThreadPoolExecutor类来创建线程池。
线程基本知识总结
weixin_44431128的博客
11-27 796
线程是调度的基本单位，状态是针对当前的线程调度的情况来描述的，因此状态 是线程的属性。 在Java中对于线程的状态有： 1. new：创建了Thread对象，但是还没有调用start（就是说内核里还没有创建对应的PCB） 2. terminated：终止。表示内核的PCB已经执行完毕，但是Thread对象还在 3. runnable：可运行的 - 正在CPU上执行的 - 在就绪队列中，随时可以去CPU上执行的 4. waiting： 5. timed_waiting： 6. blo
有关线程知识
08-16
根据提供的文件信息，我们可以从中提炼出关于线程管理和信号量操作的相关知识点。下面将详细解释这些知识点，并尽可能地提供丰富的信息。 ### 线程基础知识 #### 什么是线程？ 线程是操作系统能够进行运算调度的...
JAVA 线程通信相关知识汇总
08-19
JAVA 线程通信相关知识汇总 JAVA 线程通信是指在 JAVA 多线程环境下，多个线程之间的协作和交互，以达到共同完成任务的目标。JAVA 线程通信相关知识汇总主要介绍了 JAVA 线程通信相关知识，文中讲解非常细致，代码...
C# 线程相关知识总结
12-17
在该线程上可以创建其他线程。 图： 线程工作方式 多线程由内部线程调度程序管理，线程调度器通常是CLR委派给操作系统的函数。线程调度程序确保所有活动线程都被分配到合适的执行时间，线程在等待或阻止时 （例如...
关于线程知识点
m0_59007351的博客
04-02 366
一。线程概念：是进程的实体，是CPU调度和分配比进程更小的调度单位。 进程：是一个具有独立功能的程序在某个数据集合的一次运行活动，是操作系统进行资源分配和调度的独立单位。 线程小于进程，让多进程有高并发的特性，进程在运行的时候每个单元模块相互独立，线程之间按内存共享，优化用户体验。 二。创建线程的4种方式 1，继承Thread 类重写run方法创建线程，但是不能继承其他类； 2，实现Runnable接口重写run方法，避免单继承（接口方法没有返回值，只能抛出运行时异常无法捕获） 3，实现Call
线程相关知识点
shmilylndhhdb的博客
09-03 219
线程学习的相关知识及例题
那些年搞不懂的多线程、同步异步及阻塞和非阻塞（一）---多线程简介
weixin_30709061的博客
08-08 306
1、进程和线程的概念 进程：运行中的应用程序称为进程，拥有系统资源（cpu、内存） 线程：进程中的一段代码，一个进程中可以有多段代码。本身不拥有资源（共享所在进程的资源）； 在java中，程序入口被自动创建为主线程，在主线程中可以创建多个子线程。 区别： 1、是否占有资源问题 2、创建或撤销一个进程所需要的开销比创建或撤销一个线程所需要的开销大。 3、进程为重量级组件，线程为轻...
【多线程】| 基本知识汇总
狮子也疯狂的博客
05-21 1041
线程（Thread）是操作系统能够进行运算调度的最小单位。它被包含在进程之中，是进程中的实际运作单位。在一个进程内部，要同时干多件事，就需要同时运行多个“子任务”，我们把进程内的这些“子任务”称为线程（Thread）当Java程序启动时，一个线程会立刻运行，该线程通常叫做程序的主线程（main thread），即main方法对应的线程，它是程序开始时就执行的。在主线程中创建并启动的线程，一般称之为子线程。串行(serial)：一个CPU上，
Java多线程知识点，看这一篇就够了！（超详细）
最新发布
weixin_73616913的博客
08-13 4171
1、饿汉模式（迫切）程序启动，类加载之后，立即创建出实例2、懒汉模式（延时）在第一次使用实例的时候，再创建，否则能不创建就不创建举个例子：编译器打开一个文件，假设有一个超大的文件，
多线程重点知识归纳总结。
yzh2776680982的博客
06-08 2026
一、线程相关概念 1、程序 程序是一个指令序列。是为完成特定任务、 用某种语言编写的一组指令的集合。简单的说:就是我们写的代码 它以某些程序设计语言编写，运行于某种目标结构体系上。打个比方，程序就如同以英语（程序设计语言）写作的文章，要让一个懂得英语的人（编译器）同时也会阅读这篇文章的人（结构体系）来阅读、理解、标记这篇文章。一般的，以英语文本为基础的计算机程序要经过编译、链接而成为人难以解读，但可轻易被计算机所解读的数字格式，然后放入运行。 2、进程 ............
Java的所有线程知识精华全在CompletableFuture了
我是香菜
02-07 8996
java8中的CompletableFuture串联了java中的所有java线程知识
Java 编程之美 - 线程相关的基础知识
技术杂谈
04-09 583
本文来自作者 加多 在 GitChat 上分享 「Java 并发编程之美-线程相关的基础知识」编辑 | Mc Jin前言借用 Java 并发编程实践中的话：编写正确的程序并不容易，而编写正常的并发程序就更难了；相比于顺序执行的情况，多线程的线程安全问题是微妙而且出乎意料的，因为在没有进行适当同步的情况下多线程中各个操作的顺序是不可预期的。并发编程相比 Java 中其他知识点学习起来门槛相对较高，学
Java中线程的相关知识点汇总
瓦尔登湖
08-08 1837
Java创建线程之后，直接调用start()方法和run()的区别。 start()方法被用来启动新创建的线程，而且start()内部调用了run()方法，这和直接调用run()方法的效果不一样。当你调用run()方法的时候，只会是在原来的线程中调用，没有新的线程启动，start()方法才会启动新线程。 Java中Runnable和Callable有什么不同？ Runnable和Callable
Java多线程编程基础知识总结
Java多线程相关知识总结 Java多线程相关知识总结是Java编程语言中最重要的一部分。多线程是指在一个进程中可以同时执行多个线程，每个线程执行不同的任务，提高了程序的处理效率。下面是Java多线程相关知识的总结。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值