廖雪峰Java11多线程编程-1线程的概念-2创建新线程

最新推荐文章于 2025-08-15 17:42:04 发布
转载 最新推荐文章于 2025-08-15 17:42:04 发布 · 144 阅读 · 0 ·
CC 4.0 BY-SA版权
原文链接：http://www.cnblogs.com/csj2018/p/10915813.html
文章标签：

#java #操作系统

本文围绕Java多线程展开，介绍了创建新线程的三种方法，包括使用Thread、Runnable接口、Futrue和Callable。强调启动线程时直接调用run()方法无效，新线程和主线程默认同时执行，由操作系统调度。还阐述了线程优先级的设置与获取，指出程序无法决定线程调度顺序。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

Java语言内置多线程支持：

  • 一个Java程序实际上是一个JVM进程
  • JVM用一个主线程来执行main()方法
  • 在main()方法中又可以启动多个线程

1.创建新线程

1.1 方法一：使用Thread创建线程

创建MyThread类：

  • 从Thread派生
  • 覆写run()方法
  • 创建MyThread()实例
  • 调用start()启动线程
class MyThread extends Thread{
    public void run(){
        System.out.println("子线程");
    }
}
public class Main {
    public static  void main(String[] args){
        Thread t = new MyThread();
        t.start();
    }
}

1418970-20190609141316985-2073695728.png
疯狂Java示例

package com.thread;

public class FirstThread extends Thread{
    private int i;
    public FirstThread(){}
    public FirstThread(String name){
        super(name);
    }
    public void run(){
        for(;i<10;i++) {
            System.out.println(getName()+i);
        }
    }
    public static void main(String[] args) throws InterruptedException{
        for(int i=0;i<10;i++){
            System.out.println(Thread.currentThread().getName()+i);
            if(i==5){
                new FirstThread().start();
                Thread.sleep(500);
                new FirstThread("通过集成Thread创建新线程").start();

            }
            Thread.sleep(500);
        }
    }
}

1418970-20190528195416006-597594251.png

1.2 方法二：使用Runnable接口创建新线程

如果一个类已经从某个类派生，无法从Thread继承：

  • 实现Runnable接口
  • 覆写run()接口
  • 在main()方法中创建Runnable实例
  • 创建Thread实例并传入Runnable
  • 调用start()启动线程
class MyThread implements Runnable{
    public void run(){
        System.out.println("子线程");
    }
}
public class Main {
    public static  void main(String[] args){
        Runnable mt = new MyThread();
        Thread t = new Thread(mt);
        t.start();
    }
}

1418970-20190609142017083-289635030.png

疯狂Java示例

package com.thread;

public class SecondThread implements Runnable{
    private int i;
    public void run(){
        for(;i<10;i++){
            System.out.println(Thread.currentThread().getName()+"的循环变量"+i);
        }
    }
    public static void main(String[] args) throws InterruptedException{
        for(int i=0;i<10;i++){
            System.out.println(Thread.currentThread().getName()+"的循环变量"+i);
            if(i==5){
                SecondThread st = new SecondThread();
                new Thread(st,"新线程1").start();
                Thread.sleep(500);
                new Thread(st,"新线程2").start();
                Thread.sleep(500);
            }
            Thread.sleep(500);
        }
    }
}

1418970-20190528200822441-445807415.png

1.3 方法三：使用Futrue和Callable创建子线程

package com.thread;

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

public class ThirdThread{
    public static void main(String[] args) throws InterruptedException{
        ThirdThread th = new ThirdThread();
        FutureTask<Integer> task = new FutureTask<Integer>((Callable<Integer>)()->{
            int i=0;
            for(;i<10;i++){
                System.out.println(Thread.currentThread().getName()+"的循环变量的值"+i);
            }
            return i;
        });
        for(int i=0;i<10;i++){
            System.out.println(Thread.currentThread().getName()+"循环变量的值"+i);
            if(i==5){
                new Thread(task,"有返回值的线程").start();
            }
            Thread.sleep(500);
        }
        try{
            System.out.println("线程task的返回值："+task.get());
        }catch (ExecutionException e){
            e.printStackTrace();
        }
    }
}

1418970-20190528195605048-2097000123.png

2.启动线程需要注意的地方

2.1 直接调用run()方法

直接调用run()方法是无效的，相当调用普通的Java的方法，当前线程没有任何的改变，也不会启动新的线程。

class MyThread extends Thread{
    public void run(){
        System.out.println("当前线程"+Thread.currentThread().getName()+"\tHello");
    }
}

public class Main {
    public static  void main(String[] args){
        Thread t = new MyThread();
        t.run();//直接调用run()方法
        Thread t2 = new MyThread();
        t2.start();
        System.out.println("主线程"+Thread.currentThread().getName());
    }
}

1418970-20190609144345036-161158297.png

start源码

class Thread implements Runnable {
    public synchronized void start() {
        if (threadStatus != 0)
            throw new IllegalThreadStateException();
        group.add(this);

        boolean started = false;
        try {
            start0(); //调用JVM虚拟机内部的start0()方法
            started = true;
        } finally {
            try {
                if (!started) {
                    group.threadStartFailed(this);
                }
            } catch (Throwable ignore) {}
        }
    }

    private native void start0(); //native表示JVM虚拟机内部的C代码实现的，不是由Java代码实现的

2.2 新线程和主线程是同时执行

默认情况下，新线程和主线程是同时执行的，由操作系统调度，程序本身无法确认线程的的调度顺序

class HelloThread extends Thread{
    String name;
    public HelloThread(String name){
        this.name = name;
    }
    public void run() {
        for (int i = 0; i < 3; i++) {
            System.out.println("Hello, " + name + "!");
            try{
                Thread.sleep(100);
            }catch (InterruptedException e){
                e.printStackTrace();
            }
        }
    }
}

public class Main {
    public static  void main(String[] args){
        Thread t1 = new HelloThread("Bob");
        t1.start();
        Thread t2 = new HelloThread("Alice");
        t2.start();
        for(int i=0;i<3;i++){
            System.out.println("Main!");
            try{
                Thread.sleep(100);
            }catch (InterruptedException e){
                e.printStackTrace();
            }
        }
    }
}

1418970-20190609145950675-1573353895.png

3 线程的优先级

  • 可以对线程设定优先级 Thread.setPriority(int n)//1-10，默认值5
  • getPriority()获取线程的优先级
  • 每个线程默认的优先级都与创建它的父线程的优先级相同，默认情况下，main线程具有普通优先级，其子线程也具有普通优先级。
  • 优先级高的线程被操作系统调度的优先级高
  • 不能通过设置优先级来确保功能的执行顺序
public class PriorityTest extends Thread{
    public PriorityTest(String name){
        super(name);
    }
    public void run(){
        for(int i=0;i<50;i++){
            System.out.println(getName()+"，其优先级是："+getPriority()+"的循环变量的值为："+i);
        }
    }
    public static void main(String[] args){
        Thread.currentThread().setPriority(6);
        for(int i=0;i<30;i++){
            if(i==10){
                PriorityTest low = new PriorityTest("低级");
                low.start();
                System.out.println("创建之初的优先级："+low.getPriority());
                low.setPriority(Thread.MIN_PRIORITY);
            }
            if(i==20){
                PriorityTest high = new PriorityTest("高级");
                high.start();
                System.out.println("创建之初的优先级："+high.getPriority());
                high.setPriority(Thread.MAX_PRIORITY);
            }
        }
    }
}

高优先级的线程将会获得更多的执行机会，因此尽管高优先级的执行晚，却早结束。
1418970-20190609154237642-1111112610.png
虽然Java提供了10个优先级，但不同操作系统的优先级并不相同，而且也不能很好的和Java的10个优先级对应，因此尽量使用MAX_PRIORITY, MIN_PRIORITY, NORM_PRIORITY

4总结：

  • Java用Thread对象表示一个线程，通过调用start()启动一个线程
  • 一个线程对象只能调用一次start()
  • 线程的执行代码是run()方法
  • 线程调度由操作系统决定，程序本身无法决定
  • Thread.sleep()可以把当前线程暂停一段时间

转载于:https://www.cnblogs.com/csj2018/p/10915813.html

【Java 11】多线程 - 程序、进程、线程、线程的创建和使用、线程的生命周期、线程的同步、线程的通信、JDK5.0新增线程创建方式
Wmiao
08-18 370
一 Idea 1 快捷补全 new Method() 使用Alt + Enter 可补全 Method method = new Method()； psvm : 可生成 main 方法 sout : System.out.println() 快捷输出 soutp=System.out.println("方法形参名 = " + 形参名); soutv=System.out.println("变量名 = " + 变量); soutm=System.out.println(“当前类名.当前方法”
python3基础教程-廖雪峰_Python3基础教程-廖雪峰[带标签完整版]
weixin_30760143的博客
02-03 1617
Python教程... 5Python简介... 7安装Python. 12Python解释器... 16第一个Python程序... 18使用文本编辑器... 19Python代码运行助手... 25输入和输出... 28Python基础... 32数据类型和变量... 33字符串和编码... 43使用list和tuple. 53条件判断... 60循环... 64使用dict和set 67函数...
Java线程：创建与启动
weixin_34186950的博客
09-13 415
Java线程：创建与启动   SCJP5学习笔记   一、定义线程   1、扩展java.lang.Thread类。   此类中有个run()方法，应该注意其用法：public void run() 如果该线程是使用独立的 Runnable 运行对象构造的，则调用该 Runnable 对象的 run 方法；否则，该方法不执行任何操作并返回。   Thread 的...
java 开启线程的三种方法
u014248032的博客
06-13 3965
1 继承Thread类,重写run方法(不推荐,因为java的单继承局限性) package study_02; /* * 继承Thread类,重写run方法 * */ public class TestThread extends Thread{ @Override public void run() { for (int i = 0; i < 20; i++) { ...
java 高并发（多线程）100例 - 1 - 开启线程三种方式
pengweismile的专栏
02-26 1536
第一例， 启动线程的三种方式 1. 继承Thread 类。 class TestThread extends Thread { @Override public void run(){ SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss"); System.out.pr...
2018廖雪峰的java教程(稀有资源)
weixin_43743766的博客
12-11 4015
教程内容：Eclipse中提供了一个课程源码插件，找到当前正在学习的课程，双击导入，就可以直接导入项目，开始编写代码并运行了。JAVA基础系列共16门课程，覆盖了安装JDK、面向对象基础、异常、反射、泛型、集合、IO、正则、加密、Maven等各个主要知识。   教程目录： Java快速入门 快速介绍Java的历史，讲解Java基本语法、数据类型，掌握如何使用Eclipse IDE并快速编写...
廖雪峰 Java教程文档.zip
09-27
8. **多线程**：Java支持多线程编程，教程会介绍线程的创建、同步机制（如synchronized关键字、wait/notify方法）、线程池等。 9. **网络编程**：讲解Socket编程，包括TCP和UDP通信，以及服务器端和客户端的实现。 ...
廖雪峰全套Python教程PDF下载 - 1-3版完整学习手册
4. 并发编程：了解多线程和多进程编程，以及异步编程的概念和实现方法。 5. 脚本编写和网络编程：学习如何编写Python脚本，并掌握基本的网络编程技能。 知识点四：廖雪峰教程的特点 廖雪峰的教程之所以广受好评，是...
Python学习笔记_廖雪峰Python教程学习笔记与代码实践_包含Python基础语法函数式编程面向对象编程模块与包错误处理IO操作多线程网络编程数据库操作等完整.zip
08-05
本文档为“Python学习笔记_廖雪峰Python教程学习笔记与代码实践_包含Python基础语法函数式编程面向对象编程模块与包错误处理IO操作多线程网络编程数据库操作等完整.zip”的学习笔记内容概述，详细涵盖了Python编程的...
Python3教程-廖雪峰带
12-01
《Python3教程-廖雪峰带》是一本深受初学者喜爱的Python编程教材，由知名技术博主廖雪峰编写。这本书以简洁明了的语言和丰富的实例，为读者提供了全面而深入的Python3学习路径，旨在帮助新手快速掌握这门强大的编程...
Java中使用Thread创建多线程并启动
小灰笔记
03-23 604
按照教程实现了一个单线程的创建，但是单线程的创建于启动并不是很有实用价值的。毕竟直接在main方法中放着相关的执行操作本身也就是一种单线程的实现。接下来在之前用过的代码基础上稍作修改，形成如下代码： class ThreadDemoextends Thread {        ThreadDemo(){};               ThreadDemo(String szName
java核心类库（八） 多线程
weixin_43835305的博客
09-04 359
java中多线程的使用，线程锁，线程池等概念
Java并发编程实例--12.使用线程工厂创建线程
老徐的博客只有干货
05-05 919
工厂模式是面向对象编程世界中最有用的设计模式。它是一个创新型的模式，目标是开发一个对象，这个对象的任务是去创建其他类对象。这样一来，如果我们想创建某些类的对象就不需要使用new关键字。好处有以下几点：1.容易改变对象的类或者创建这些对象的方式；2.容易限制所创建的对象。例如，我们只能创建N个某类型的对象；3.容易生成对象创建的统计数据；Java并发API提供了ThreadFactory接口以实现一...
java 多线程
Liang____________的博客
05-25 349
                                                           java 多线程编程进程的特点有：                    -&gt;进程是系统运行程序的基本单位                    -&gt;进程都有一个自己独立的，一块内存空间和一组系统资源                    -&gt;进程的内部数据和状态...
Java基础-多线程-①线程的创建和启动
weixin_30547797的博客
07-18 122
简单阐释进程和线程 对于进程最直观的感受应该就是“windows任务管理器”中的进程管理： 　　（计算机原理课上的记忆已经快要模糊了，简单理解一下）：一个进程就是一个“执行中的程序”，是程序在计算机上的一次运行活动。程序要运行，系统就在内存中为该程序分配一块独立的内存空间，载入程序代码和资源进行执行。程序运行期间该内存空间不能被其他进程直接访问。系统以进程为基本单位进行系统资源的调度和分配...
关于多线程
qq_44871457的博客
08-12 424
目录1.多线程概述2.实现线程的两种方式1.实现线程方法一（继承Thread,重写run）2.run（）和start（）的区别3.实现线程方法二（实现Runable接口）3.线程生命周期4.获取线程的名字5.获取当前线程对象6.关于sleep()方法7.关于sleep()的面试题 1.多线程概述 2.实现线程的两种方式 建议使用接口方式 1.实现线程方法一（继承Thread,重写run） start()方法的作用是:启动一个分支线程，在JVM中开辟一个新的空间，这段代码任务完成之后，
java线程启动方法_在main方法中启动手动线程
weixin_36468605的博客
03-02 388
我在java中使用一些低级多线程，我有两种方法生成和使用：public class Producer {private LinkedList list = new LinkedList();private final int LIMIT = 10;private Object lock = new Object();public void produce() throws InterruptedE...
Python多线程编程(一）：threading 模块 Thread 类的用法详解
热门推荐
frank 的专栏
12-19 27万+
我们进行程序开发的时候，肯定避免不了要处理并发的情况。 一般并发的手段有采用多进程和多线程。 但线程比进程更轻量化，系统开销一般也更低，所以大家更倾向于用多线程的方式处理并发的情况。 Python 提供多线程编程的方式。 本文基于 Python3 讲解,Python 实现多线程编程需要借助于 threading 模块。 所以，我们要在代码中引用它。 import threading thread...
Java——琐碎知识点2
最新发布
2401_88065518的博客
08-15 682
Java基础知识点：Java官方帮助文档、Scanner扫描器、快捷键、“==”做比较、获取代码运行时间、打印对象名时不会出现内存地址的类型、Arrays类常用方法、循环标号的使用、Lambda表达式、异常处理、Java浮点数的精度问题（BigDecimal）、DecimalFormat格式化数字工具、printf格式化输出
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值