AI 助理
备案控制台
开发者社区 开发与运维 文章 正文

java线程(1)--概念基础

2016-02-25 789
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 参考：http://lavasoft.blog.51cto.com/62575/99150 http://blog.csdn.net/baby_newstar/article/details/6783752 http://www.runoob.com/java/java-multithreading.html 1.操作系统中的进程和线程 进程是指一个内存中运行的应用程序，每个进程都有自己独立的一块内存空间，一个进程中可以启动多个线程。

参考：http://lavasoft.blog.51cto.com/62575/99150

http://blog.csdn.net/baby_newstar/article/details/6783752

http://www.runoob.com/java/java-multithreading.html

1.操作系统中的进程和线程

进程是指一个内存中运行的应用程序，每个进程都有自己独立的一块内存空间，一个进程中可以启动多个线程。比如在Windows系统中，一个运行的exe就是一个进程。

线程是指进程中的一个执行流程，一个进程中可以运行多个线程。比如java.exe进程中可以运行很多线程。线程总是属于某个进程，进程中的多个线程共享进程的内存。

2.java中的线程

一个Java应用总是从main()方法开始运行，mian()方法运行在一个线程内，它被称为主线程。

其他线程通过使用java.lang.Thread类或者java.lang.Runnable接口编写代码来定义、实例化和启动新线程。

线程又分用户线程和守护线程。只有通过设置setDaemon(true)的线程才是守护线程。用户线程的生命周期由该线程自定义，比如while(true)一直执行。守护线程的生命周期是由创造它的线程决定的，父线程死掉了，它也就立即死亡而不管是否有任务还没有执行。抽象的理解就是：守护线程是工蜂，蜂后死掉后也会跟着死掉。

3.线程的生命周期

  • 新建状态:使用 new 关键字和 Thread 类或其子类建立一个线程对象后，该线程对象就处于新建状态。它保持这个状态直到程序 start() 这个线程。
  • 就绪状态:当线程对象调用了start()方法之后，该线程就进入就绪状态。就绪状态的线程处于就绪队列中，要等待JVM里线程调度器的调度。
  • 运行状态:如果就绪状态的线程获取 CPU 资源，就可以执行 run()，此时线程便处于运行状态。处于运行状态的线程最为复杂，它可以变为阻塞状态、就绪状态和死亡状态。
  • 阻塞状态:如果一个线程执行了sleep（睡眠）、suspend（挂起）等方法，失去所占用资源之后，该线程就从运行状态进入阻塞状态。在睡眠时间已到或获得设备资源后可以重新进入就绪状态。
  • 死亡状态:一个运行状态的线程完成任务或者其他终止条件发生时，该线程就切换到终止状态。
  • 如图：

4.创建一个线程

Java提供了两种创建线程方法：

  • 通过实现Runable接口；
  • 通过继承Thread类本身。

1、如果是扩展java.lang.Thread类的线程，则直接new即可。 

2、如果是实现了java.lang.Runnable接口的类，则用Thread的构造方法：
Thread(Runnable target) 
Thread(Runnable target, String name) 
Thread(ThreadGroup group, Runnable target) 
Thread(ThreadGroup group, Runnable target, String name) 
Thread(ThreadGroup group, Runnable target, String name, long stackSize)

4.1实现Runnable接口

package com.test.java.thread;

/**
 * 学习线程
 * Created by mrf on 2016/2/25.
 */
public class NewThread  implements Runnable{
    Thread thread;
    NewThread(){
        //创建第二个新线程
        thread = new Thread(this,"Demo Thread");
        System.out.println("我是实现Runnable接口的类，我被创建了。而且我开始创建另一个线程(name,priority,groupname)："+thread);
        thread.start();
    }

//第二个线程入口
    @Override
    public void run() {
        System.out.println("------------------我是实现Runnable接口的运行入口，我要开始运行了。-----------------------");
        try {
            for (int i = 0; i < 5; i++) {
                System.out.println("Child Thread:"+i);
                //暂停线程
                Thread.sleep(50);
            }
        } catch (InterruptedException e) {
            System.out.println("Child interrupted");
            e.printStackTrace();
        }
        System.out.println("---------------我这个线程就要运行结束了.------------------------");

    }
}

class ThreadDemo{
    public static void main(String[] args) {
        System.out.println("===========main线程开始运行。==============");
        System.out.println("当前运行的是main线程："+Thread.currentThread());
        new NewThread();//创建一个新线程
        try {
            for (int i =0; i<5; i++){
                System.out.println("main thread:"+i);
                Thread.sleep(100);
            }
        } catch (InterruptedException e) {
            System.out.println("main thread interruped.");
            e.printStackTrace();
        }
        System.out.println("==============main线程运行结束.================");
    }
}
View Code

运行结果：

===========main线程开始运行。==============
当前运行的是main线程：Thread[main,5,main]
我是实现Runnable接口的类，我被创建了。而且我开始创建另一个线程(name,priority,groupname)：Thread[Demo Thread,5,main]
main thread:0
------------------我是实现Runnable接口的运行入口，我要开始运行了。-----------------------
Child Thread:0
Child Thread:1
Child Thread:2
main thread:1
Child Thread:3
Child Thread:4
main thread:2
---------------我这个线程就要运行结束了.------------------------
main thread:3
main thread:4
Disconnected from the target VM, address: '127.0.0.1:4625', transport: 'socket'
==============main线程运行结束.================

分析：

　　java程序从main线程开始，这是主线程。然后new NewThread(),创建了这个叫做NewThread的类，这个类的构造方法里面又调用了另一个线程，即从这里开始调用新线程了。main线程和新线程的优先级都为5，因此轮换使用cpu，所以才会出现交替打印的现象。

问题：上面的结果显示自线程运行结束后main线程才结束，那么子线程的生命周期和main有关吗？

答案是否定的，下面我将子线程的运行时间加长就会看到结果。

package com.test.java.thread;

/**
 * 学习线程
 * Created by mrf on 2016/2/25.
 */
public class NewThread  implements Runnable{
    Thread thread;
    NewThread(){
        //创建第二个新线程
        thread = new Thread(this,"Demo Thread");
        System.out.println("我是实现Runnable接口的类，我被创建了。而且我开始创建另一个线程(name,priority,groupname)："+thread);
        thread.start();
    }

//第二个线程入口
    @Override
    public void run() {
        System.out.println("------------------我是实现Runnable接口的运行入口，我要开始运行了。-----------------------");
        try {
            for (int i = 0; i < 5; i++) {
                System.out.println("Child Thread:"+i);
                //暂停线程
                Thread.sleep(500);
            }
        } catch (InterruptedException e) {
            System.out.println("Child interrupted");
            e.printStackTrace();
        }
        System.out.println("---------------我这个线程就要运行结束了.------------------------");

    }
}

class ThreadDemo{
    public static void main(String[] args) {
        System.out.println("===========main线程开始运行。==============");
        System.out.println("当前运行的是main线程："+Thread.currentThread());
        new NewThread();//创建一个新线程
        try {
            for (int i =0; i<5; i++){
                System.out.println("main thread:"+i);
                Thread.sleep(100);
            }
        } catch (InterruptedException e) {
            System.out.println("main thread interruped.");
            e.printStackTrace();
        }
        System.out.println("==============main线程运行结束.================");
    }
}
View Code

结果：

===========main线程开始运行。==============
当前运行的是main线程：Thread[main,5,main]
我是实现Runnable接口的类，我被创建了。而且我开始创建另一个线程(name,priority,groupname)：Thread[Demo Thread,5,main]
main thread:0
------------------我是实现Runnable接口的运行入口，我要开始运行了。-----------------------
Child Thread:0
main thread:1
main thread:2
main thread:3
main thread:4
==============main线程运行结束.================
Child Thread:1
Child Thread:2
Child Thread:3
Child Thread:4
---------------我这个线程就要运行结束了.------------------------

注意我将子线程的睡眠时间改成了500.这样，main线程执行完毕后子线程仍然继续执行。这个有点可以使我们在做业务代码时将不要紧的代码多线程异步执行，优化运行体验和效率。

4.2守护线程演示

还是上面的代码，我将子线程设置为守护线程，并且设置子线程运行时间>main线程，看是否main线程运行结束后守护线程直接死掉。这里注意，setDaemon一定要放在start前，因为会判断isAlive，如果活着就不能设置为守护线程了，因为已经在运行了。

package com.test.java.thread;

/**
 * 学习线程
 * Created by mrf on 2016/2/25.
 */
public class NewThread  implements Runnable{
    Thread thread;
    NewThread(){
        //创建第二个新线程
        thread = new Thread(this,"Demo Thread");
        System.out.println("我是实现Runnable接口的类，我被创建了。而且我开始创建另一个线程(name,priority,groupname)："+thread);
        thread.setDaemon(true);
        thread.start();
    }

//第二个线程入口
    @Override
    public void run() {
        System.out.println("------------------我是实现Runnable接口的运行入口，我要开始运行了。-----------------------");
        try {
            for (int i = 0; i < 5; i++) {
                System.out.println("Child Thread:"+i);
                //暂停线程
                Thread.sleep(500);
            }
        } catch (InterruptedException e) {
            System.out.println("Child interrupted");
            e.printStackTrace();
        }
        System.out.println("---------------我这个线程就要运行结束了.------------------------");

    }
}

class ThreadDemo{
    public static void main(String[] args) {
        System.out.println("===========main线程开始运行。==============");
        System.out.println("当前运行的是main线程："+Thread.currentThread());
        new NewThread();//创建一个新线程
        try {
            for (int i =0; i<5; i++){
                System.out.println("main thread:"+i);
                Thread.sleep(100);
            }
        } catch (InterruptedException e) {
            System.out.println("main thread interruped.");
            e.printStackTrace();
        }
        System.out.println("==============main线程运行结束.================");
    }
}
View Code

运行结果：

===========main线程开始运行。==============
当前运行的是main线程：Thread[main,5,main]
我是实现Runnable接口的类，我被创建了。而且我开始创建另一个线程(name,priority,groupname)：Thread[Demo Thread,5,main]
main thread:0
------------------我是实现Runnable接口的运行入口，我要开始运行了。-----------------------
Child Thread:0
main thread:1
main thread:2
main thread:3
main thread:4
Child Thread:1
Disconnected from the target VM, address: '127.0.0.1:6928', transport: 'socket'
==============main线程运行结束.================

和上一个测试对比相当明显，child thread仅仅打印了一次就结束了，说明它死掉了，说明创建他的main线程死掉后，她跟着死掉。

 4.3继承Thread

通过继承Thread，重写run方法来实现多线程。下面是实例，另外上面的代码写的不太清楚，start方法应该放外面来调用比较好。

package com.test.java.thread;

/**
 * 多线程学习---继承Thread
 * Created by mrf on 2016/2/25.
 */
public class NewThreadExtend  extends Thread{
    NewThreadExtend(){
        //创建第二个线程
        super("Demo Thread.");
        System.out.println("子线程："+this);
    }

    //通过重写run方法来实现线程业务逻辑
    public void run(){
        System.out.println("-------我是子线程，我开始运行----------------");
        try {
            for (int i = 0; i < 5; i++) {
                System.out.println("子线程："+i);
                Thread.sleep(50);
            }
        } catch (InterruptedException e) {
            System.out.println("子线程interrupted");
            e.printStackTrace();
        }
        System.out.println("-------我是子线程，我结束运行----------------");
    }

}

class ExtendThread{
    public static void main(String[] args) {
        System.out.println("========我是main线程，我开始运行："+Thread.currentThread());
        NewThreadExtend newThreadExtend = new NewThreadExtend();
        newThreadExtend.start();
        try {
            for (int i = 0; i < 5; i++) {
                System.out.println("main线程："+i);
                Thread.sleep(100);
            }
        } catch (InterruptedException e) {
            System.out.println("main线程interrupted.");
            e.printStackTrace();
        }
        System.out.println("========main线程运行结束=====================");
    }
}
View Code

运行结果：

========我是main线程，我开始运行：Thread[main,5,main]
子线程：Thread[Demo Thread.,5,main]
main线程：0
-------我是子线程，我开始运行----------------
子线程：0
子线程：1
main线程：1
子线程：2
子线程：3
子线程：4
main线程：2
-------我是子线程，我结束运行----------------
main线程：3
main线程：4
Disconnected from the target VM, address: '127.0.0.1:11051', transport: 'socket'
========main线程运行结束=====================
View Code

5.Thread的方法

 方法就不在这里赘述了，普通方法必须由thread对象来调用，比如start，静态方法可以由Thread来调用。这里再说下start，start执行的是run方法，初学的时候会很纳闷，因为没有深入源码。好吧，我也没深入，但大概看到start是加入group，然后调用start0，start0是个native method。啥是native method？看到介绍说是调用其他语言实现的代码，到这里就是jvm干的事情了，我们不知道做了什么。不过可以猜测是和操作系统交互，获取进程资源之类的吧，然后应该回调run方法。总之，要理解start就是在执行run方法，不过start看起来像是代理而已。

public void start()
使该线程开始执行；Java 虚拟机调用该线程的 run 方法。

 6.线程的几个概念

在多线程编程时，你需要了解以下几个概念：

  • 线程同步
  • 线程间通信
  • 线程死锁
  • 线程控制：挂起、停止和恢复

 7.线程同步和锁下次学习

 





唯有不断学习方能改变！ -- Ryan Miao
文章标签：
Java
关键词：
Java线程
Java概念
线程概念
Java线程概念
Java基础
ryan-miao
目录
相关文章
aliyun5518910231-27881
|
16天前
|
存储 Linux API
【Linux进程概念】—— 操作系统中的“生命体”，计算机里的“多线程”
在计算机系统的底层架构中，操作系统肩负着资源管理与任务调度的重任。当我们启动各类应用程序时，其背后复杂的运作机制便悄然展开。程序，作为静态的指令集合，如何在系统中实现动态执行？本文带你一探究竟！
aliyun5518910231-27881
49 6
【Linux进程概念】—— 操作系统中的“生命体”，计算机里的“多线程”
flzjkl
|
16天前
|
存储 监控 Java
【Java并发】【线程池】带你从0-1入门线程池
欢迎来到我的技术博客！我是一名热爱编程的开发者，梦想是编写高端CRUD应用。2025年我正在沉淀中，博客更新速度加快，期待与你一起成长。 线程池是一种复用线程资源的机制，通过预先创建一定数量的线程并管理其生命周期，避免频繁创建/销毁线程带来的性能开销。它解决了线程创建成本高、资源耗尽风险、响应速度慢和任务执行缺乏管理等问题。
flzjkl
142 60
【Java并发】【线程池】带你从0-1入门线程池
Bluening
|
5天前
|
存储 网络协议 安全
Java网络编程，多线程，IO流综合小项目一一ChatBoxes
**项目介绍**：本项目实现了一个基于TCP协议的C/S架构控制台聊天室，支持局域网内多客户端同时聊天。用户需注册并登录，用户名唯一，密码格式为字母开头加纯数字。登录后可实时聊天，服务端负责验证用户信息并转发消息。 **项目亮点**： - **C/S架构**：客户端与服务端通过TCP连接通信。 - **多线程**：采用多线程处理多个客户端的并发请求，确保实时交互。 - **IO流**：使用BufferedReader和BufferedWriter进行数据传输，确保高效稳定的通信。 - **线程安全**：通过同步代码块和锁机制保证共享数据的安全性。
Bluening
55 23
flzjkl
|
12天前
|
Java 调度
【源码】【Java并发】【线程池】邀请您从0-1阅读ThreadPoolExecutor源码
当我们创建一个`ThreadPoolExecutor`的时候，你是否会好奇🤔，它到底发生了什么？比如：我传的拒绝策略、线程工厂是啥时候被使用的？ 核心线程数是个啥？最大线程数和它又有什么关系？线程池，它是怎么调度，我们传入的线程？...不要着急，小手手点上关注、点赞、收藏。主播马上从源码的角度带你们探索神秘线程池的世界...
flzjkl
81 0
【源码】【Java并发】【线程池】邀请您从0-1阅读ThreadPoolExecutor源码
软件求生
|
27天前
|
Java 程序员 开发者
Java社招面试题：一个线程运行时发生异常会怎样？
大家好，我是小米。今天分享一个经典的 Java 面试题：线程运行时发生异常，程序会怎样处理？此问题考察 Java 线程和异常处理机制的理解。线程发生异常，默认会导致线程终止，但可以通过 try-catch 捕获并处理，避免影响其他线程。未捕获的异常可通过 Thread.UncaughtExceptionHandler 处理。线程池中的异常会被自动处理，不影响任务执行。希望这篇文章能帮助你深入理解 Java 线程异常处理机制，为面试做好准备。如果你觉得有帮助，欢迎收藏、转发！
软件求生
105 14
软件求生
|
1月前
|
安全 Java 程序员
Java 面试必问！线程构造方法和静态块的执行线程到底是谁？
大家好，我是小米。今天聊聊Java多线程面试题：线程类的构造方法和静态块是由哪个线程调用的？构造方法由创建线程实例的主线程调用，静态块在类加载时由主线程调用。理解这些细节有助于掌握Java多线程机制。下期再见！ 简介： 本文通过一个常见的Java多线程面试题，详细讲解了线程类的构造方法和静态块是由哪个线程调用的。构造方法由创建线程实例的主线程调用，静态块在类加载时由主线程调用。理解这些细节对掌握Java多线程编程至关重要。
软件求生
57 13
心疼你的一切
|
1月前
|
安全 Java 开发者
【JAVA】封装多线程原理
Java 中的多线程封装旨在简化使用、提高安全性和增强可维护性。通过抽象和隐藏底层细节，提供简洁接口。常见封装方式包括基于 Runnable 和 Callable 接口的任务封装，以及线程池的封装。Runnable 适用于无返回值任务，Callable 支持有返回值任务。线程池（如 ExecutorService）则用于管理和复用线程，减少性能开销。示例代码展示了如何实现这些封装，使多线程编程更加高效和安全。
心疼你的一切
62 8
潜意识Java
|
2月前
|
缓存 Java 开发者
Java字面量详解：概念、分类与使用实例
本文介绍了Java字面量的概念、分类及应用。
潜意识Java
63 11
蓝易云
|
2月前
|
监控 Java
java异步判断线程池所有任务是否执行完
通过上述步骤，您可以在Java中实现异步判断线程池所有任务是否执行完毕。这种方法使用了 `CompletionService`来监控任务的完成情况，并通过一个独立线程异步检查所有任务的执行状态。这种设计不仅简洁高效，还能确保在大量任务处理时程序的稳定性和可维护性。希望本文能为您的开发工作提供实用的指导和帮助。
蓝易云
126 17
大数据文摘
|
3月前
|
Java
Java—多线程实现生产消费者
本文介绍了多线程实现生产消费者模式的三个版本。Version1包含四个类：`Producer`（生产者）、`Consumer`（消费者）、`Resource`（公共资源）和`TestMain`（测试类）。通过`synchronized`和`wait/notify`机制控制线程同步，但存在多个生产者或消费者时可能出现多次生产和消费的问题。 Version2将`if`改为`while`，解决了多次生产和消费的问题，但仍可能因`notify()`随机唤醒线程而导致死锁。因此，引入了`notifyAll()`来唤醒所有等待线程，但这会带来性能问题。
大数据文摘
91 1
Java—多线程实现生产消费者

热门文章

最新文章

  • 1
    【AI程序员】通义灵码 AI 程序员全面上线JAVA使用体验
  • 2
    Java也能快速搭建AI应用？一文带你玩转Spring AI可落地性
  • 3
    从理论到实践：使用JAVA实现RAG、Agent、微调等六种常见大模型定制策略
  • 4
    一天成为Java开发高手：用飞算JavaAI实现十倍提效
  • 5
    Java+机器学习基础：打造AI学习基础
  • 6
    深入理解Java锁升级：无锁 → 偏向锁 → 轻量级锁 → 重量级锁（图解+史上最全）
  • 7
    Java实战：使用HttpClient实现图片下载与本地保存
  • 8
    课时3：Java简介（Java主要特点）
  • 9
    【原理】【Java并发】【volatile】适合初学者体质的volatile原理
  • 10
    尼恩一键开发环境： vagrant+java+springcloud+redis+zookeeper镜像下载(&制作详解)
  • 1
    Redis的线程模型
    14
  • 2
    Java网络编程，多线程，IO流综合小项目一一ChatBoxes
    55
  • 3
    【源码】【Java并发】【线程池】邀请您从0-1阅读ThreadPoolExecutor源码
    81
  • 4
    Python实用技巧：轻松驾驭多线程与多进程，加速任务执行
    22
  • 5
    【Java并发】【线程池】带你从0-1入门线程池
    142
  • 6
    【Linux进程概念】—— 操作系统中的“生命体”，计算机里的“多线程”
    49
  • 7
    【YashanDB 知识库】用 yasldr 配置 Bulkload 模式作单线程迁移 300G 的业务数据到分布式数据库，迁移任务频繁出错
    24
  • 8
    Java社招面试题：一个线程运行时发生异常会怎样？
    105
  • 9
    python3多线程中使用线程睡眠
    54
  • 10
    MySQL底层概述—3.InnoDB线程模型
    59

    • 相关课程

    更多
  • Java面试疑难点解析 - 面试技巧及语言基础
  • Java面试疑难点解析 - Java Web开发
  • Java面试疑难点解析 - 系统架构及项目设计
  • Java编程入门
  • Java面向对象编程
  • Java高级编程

    • 相关电子书

    更多
  • Spring Cloud Alibaba - 重新定义 Java Cloud-Native
  • The Reactive Cloud Native Arch
  • JAVA开发手册1.5.0

    • 相关实验场景

    更多
  • 阿里云平台上进行Java程序的编译与运行
  • 观察进程的并发性
  • 使用Java面向对象编写网络通信程序应用
  • 手动部署Java Web环境（Alibaba Cloud Linux 2）
  • 搭建Java Web开发环境（Anolis OS）
  • RocketMQ中使用Java客户端发送消息和消费的应用
    • 下一篇
    阿里云百炼已上线超强推理开源模型QwQ-32B，尺寸更小，性能比肩DeepSeek满血版