70 java多线程_2 _线程的组成与创建线程

最新推荐文章于 2021-04-03 08:46:49 发布
最新推荐文章于 2021-04-03 08:46:49 发布
阅读量180 收藏
点赞数
分类专栏： # 多线程与并发编程 文章标签： java 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wang_luwei/article/details/107489664
版权

文章目录

线程组成

任何一个线程都具有基本的组成部分：

  1. CPU时间片：操作系统(OS)会为每个线程分配执行时间。

  2. 运行数据：

    • 堆空间:存储线程需使用的对象，多个线程可以共享堆中的对象。
    • 栈空间:存储线程需使用的局部变量，每个线程都拥有独立的栈。

  3. 线程的逻辑代码。

线程特点

  1. 线程抢占式执行：
    • 效率高
    • 可防止单一线程长时间独占CPU
  2. 在单核CPU中，宏观上同时执行，微观上顺序执行。

创建线程

创建线程三种方式：

  1. 继承Thread类，重写run方法【重点】
  2. 实现Runnable接口【重点】
  3. 实现Callable接口（后面再讲）

创建线程（一）

第一种方式：

  1. 第一步，继承Thread类，
  2. 第二步，重写run()方法，在run()方法内编写功能代码
  3. 第三步，创建线程对象（new）
  4. 第四步，调用start()方法，这个方法是启动线程（不能调用run()方法，因为这相当于调用普通对象的一个普通方法）

创建线程的代码:

package com.wlw.thread;

/**
 * 线程类
 * 创建线程的第一种方式
 */
public class MyThread extends Thread{ //第一步，继承Thread类，
    @Override
    public void run() { //第二步，重写run()方法，在run()方法内编写功能代码
        for (int i = 0; i < 2000; i++) {
            System.out.println("子线程-------------"+i);
        }
    }
}

package com.wlw.thread;

public class TestThread {
    public static void main(String[] args) {

       //第三步，创建线程对象（new）
        MyThread myThread = new MyThread();

        //第四步，调用start()方法，这个方法是启动线程
        myThread.start();
 
        //主线程执行
        for (int i = 0; i < 2000; i++) {
            System.out.println("主线程----------------------"+i);
        }
    }
}
//循环次数过小，可能出现运行结果不符合理想，总是一个线程执行完，再执行另一个线程，此时就加大循环次数，应该就会出现理想结果，如下：（部分执行结果）
/*
子线程-------------241
主线程----------------------261
子线程-------------242
主线程----------------------262
子线程-------------243
主线程----------------------263
主线程----------------------264
主线程----------------------265
子线程-------------244
子线程-------------245
子线程-------------246
主线程----------------------266
子线程-------------247
子线程-------------248
子线程-------------249
*/

获取和修改线程名称

  1. 获取线程ID和线程名称：
    • 在Thread的子类中调用this. getId ()或this. getName () （只适合在继承了Thread的类中使用）
    • 使用Thread. currentThread(). getId()和Thread. currentThread (). getName () （在哪都能用）
  2. 修改线程名称：（只能修改线程名称，在线程启动之前修改）
    • 调用线程对象的setName()方法（创建完对象，再调用setName()）
    • (建议使用)使用线程子类的构造方法赋值（在带参构造方法中，调用父类Thread的带参构造，super（name））

代码：

package com.wlw.thread;

/**
 * 线程类
 * 创建线程的第一种方式
 */
public class MyThread extends Thread{ //第一步，继承Thread类，


    public MyThread() {
    }
    public MyThread(String name){
        super(name);
    }

    @Override
    public void run() { //第二步，重写run()方法，在run()方法内编写功能代码
        for (int i = 0; i < 2000; i++) {
            //第一种方式：在Thread的子类中调用this. getId ()或this. getName ()  （只适合在继承了Thread的类中使用）
            //System.out.println("线程ID:"+this.getId()+"线程名称："+this.getName()+",子线程-------------"+i);

            //第二种方式:使用Thread. currentThread()  获取当前线程
            System.out.println("线程ID:"+Thread.currentThread().getId() +"线程名称："+Thread.currentThread().getName() +",子线程-------------"+i);
        }
    }
}

package com.wlw.thread;

public class TestThread {
    public static void main(String[] args) {

        //第三步，创建线程对象（new）
        MyThread myThread01 = new MyThread("我的子线程1");

        //修改线程名称，setName()
        //thread_demo01.setName("我的子线程1");

        //第四步，调用start()方法，这个方法是启动线程
        myThread01.start();

        MyThread myThread02 = new MyThread("我的子线程2");
        //thread_demo02.setName("我的子线程2");
        myThread02.start();

        //主线程执行
        for (int i = 0; i < 2000; i++) {
            System.out.println("主线程----------------------"+i);
        }
    }
}

卖票案例

/**
*使用继承Thread类实现4个窗口各卖100张票
*/
package com.wlw.thread;

/**
 * 卖票窗口类（继承类）
 */
public class TickeWin extends Thread {

    public TickeWin(){
    }

    public TickeWin(String name){
        super(name);
    }

    @Override
    public void run() {
        //买票功能
        for (int i = 1; i <= 100; i++){
            System.out.println("ID:"+Thread.currentThread().getId()+","+Thread.currentThread().getName()+"，卖出了第"+i+"张票");
        }

       /* int ticket = 100;//票
        while (true){
            if(ticket <= 0){
                break;
            }
            System.out.println(Thread.currentThread().getName()+"，卖出了第"+ticket+"张票");
            ticket--;
        }*/
    }
}

package com.wlw.thread;

public class TestWin {
    public static void main(String[] args) {
        //创建四个对象
        TickeWin tickeWin1 = new TickeWin("窗口1");
        TickeWin tickeWin2 = new TickeWin("窗口2");
        TickeWin tickeWin3 = new TickeWin("窗口3");
        TickeWin tickeWin4 = new TickeWin("窗口4");

        //启动线程
        tickeWin1.start();
        tickeWin2.start();
        tickeWin3.start();
        tickeWin4.start();
    }
}

创建线程（二）

第二种方式：

  1. 第一步：定义一个类，实现Runnable接口
  2. 第二步，覆盖run()方法，在run()方法内编写功能代码
  3. 第三步，创建实现类对象（new）
  4. 第四步，创建线程对象（new），把实现类对象传递给线程对象（这个方法可以同时传递线程名称）
  5. 第五步，调用start()方法，这个方法是启动线程

代码:

package com.wlw.thread;
/**
 * 线程类
 * 创建线程的第二种方式
 */
public class MyRunnable implements Runnable{ //第一步：定义一个类，实现Runnable接口
    @Override
    public void run() { //第二步，覆盖run()方法，在run()方法内编写功能代码
        for (int i = 0; i < 2000; i++) {
            System.out.println(Thread.currentThread().getName()+"，子线程---------------"+i);
        }
    }
}


package com.wlw.thread;

public class TestRunnable {
    public static void main(String[] args) {
        //第三步，创建实现类对象（new）
        //创建MyRunnable对象，表示线程要实现的功能
        MyRunnable myRunnable = new MyRunnable();

        //第四步，创建线程对象，把实现类对象传递给线程对象
        Thread thread = new Thread(myRunnable,"我的线程");

        //第五步，调用start()方法，这个方法是启动线程
        thread.start();

        for (int i = 0; i < 2000; i++) {
            System.out.println("主线程========================"+i);
        }
    }
}

补充使用匿名内部类：

代码:

package com.wlw.thread;

public class TestRunnable {
    public static void main(String[] args) {

        /*
        //第三步，创建实现类对象（new）
        //创建MyRunnable对象，表示线程要实现的功能
        MyRunnable myRunnable = new MyRunnable();

        //第四步，创建线程对象，把实现类对象传递给线程对象
        Thread thread = new Thread(myRunnable,"我的线程");

        //第五步，调用start()方法，这个方法是启动线程
        thread.start();
        */

        //使用匿名内部类
        //创建可运行对象，相当于new一个Runnable的子类
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 2000; i++) {
                    System.out.println(Thread.currentThread().getName()+"，子线程---------------"+i);
                }
            }
        };
        //创建线程
        Thread thread = new Thread(runnable,"我的匿名内部类的线程");
        thread.start();

        for (int i = 0; i < 2000; i++) {
            System.out.println("主线程========================"+i);
        }
    }
}

Runnable案例1：

四个窗口共卖100张票

注意：会出现多个窗口卖了同一张票，这是一个线程安全问题，后面解决（！！！！！！！！！！！）

package com.wlw.thread.caseDemo;

/**
 * 票类（共享资源）
 */
public class Ticket implements Runnable{

    int ticket = 100; //票总共100张

    //售票功能
    @Override
    public void run() {
        while (true){
            if(ticket <= 0){
                break;
            }
            System.out.println(Thread.currentThread().getName()+"卖了第"+ticket+"张票");
            ticket--;
        }
    }
}

package com.wlw.thread.caseDemo;

public class TestTicket {
    public static void main(String[] args) {

        // 创建实现类对象
        Ticket ticket = new Ticket();

        //创建线程对象
        Thread thread1 = new Thread(ticket,"窗口1");
        Thread thread2 = new Thread(ticket,"窗口2");
        Thread thread3 = new Thread(ticket,"窗口3");
        Thread thread4 = new Thread(ticket,"窗口4");

        //调用start()方法，启动线程
        thread1.start();
        thread2.start();
        thread3.start();
        thread4.start();

        /*
        会出现多个窗口卖了同一张票，这是一个线程安全问题，后面解决(!!!!!!!!!!!!!!!!)
         */
    }
}

Runnable案例2：

注意：一开始会出现存取钱时，余额显示不准确，这是一个线程安全问题，后面解决（！！！！！！！！！！！）

package com.wlw.thread.caseDemo;
/**
 * 银行卡类
 */
public class BankCard {
    private Double money;

    public Double getMoney() {
        return money;
    }

    public void setMoney(Double money) {
        this.money = money;
    }
}

package com.wlw.thread.caseDemo;
/**
 * 存钱
 */
public class AddMoney implements Runnable {

    private BankCard bankCard;
    public AddMoney(BankCard bankCard){
        this.bankCard = bankCard;
    }

    //存钱功能
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            bankCard.setMoney(bankCard.getMoney() + 1000);
            System.out.println(Thread.currentThread().getName()+"存了1000块钱，余额是："+bankCard.getMoney());
        }

    }
}

package com.wlw.thread.caseDemo;
/**
 * 取钱
 */
public class SubMoney implements Runnable {
    private BankCard bankCard;
    public SubMoney(BankCard bankCard){
        this.bankCard = bankCard;
    }

    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            if(bankCard.getMoney() >= 1000){
                bankCard.setMoney(bankCard.getMoney()-1000);
                System.out.println(Thread.currentThread().getName()+"取了1000块钱，余额是:"+bankCard.getMoney());
            }else {
                System.out.println("余额不足");
                i--;
            }
        }

    }
}

package com.wlw.thread.caseDemo;

public class TestBankCard {
    public static void main(String[] args) {

        //1.创建银行卡
        BankCard bankCard = new BankCard();
        bankCard.setMoney(0.0);

        //2.创建存取功能对象
        AddMoney addMoney = new AddMoney(bankCard);
        SubMoney subMoney = new SubMoney(bankCard);

        //3.创建线程对象
        Thread thread1 = new Thread(addMoney,"存钱线程");
        Thread thread2 = new Thread(subMoney,"取钱线程");

        //4.启动线程
        thread1.start();
        thread2.start();
    }
}

使用匿名内部类：

package com.wlw.thread.caseDemo;

public class TestBankCard2 {
    public static void main(String[] args) {

        //1.创建银行卡
        BankCard bankCard = new BankCard();
        bankCard.setMoney(0.0);

        //2.存取功能
        Runnable add = new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 10; i++) {
                    bankCard.setMoney(bankCard.getMoney() + 1000);
                    System.out.println(Thread.currentThread().getName()+ "存了1000块钱，余额是：" +bankCard.getMoney());
                }
            }
        };
        Runnable sub = new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 10; i++) {
                    if(bankCard.getMoney() >= 1000){
                        bankCard.setMoney(bankCard.getMoney() - 1000);
                        System.out.println(Thread.currentThread().getName()+ "取了1000块钱，余额是：" +bankCard.getMoney());
                    }else {
                        System.out.println("余额不足，请充值");
                        i--;
                    }

                }
            }
        };

        //3.创建线程对象,并启动
         new Thread(add,"存钱线程").start();
         new Thread(sub,"取钱线程").start();

    }
}
悬浮海
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
java 多线程详解（持续更新）
Ferao的博客
05-28 2340
目录 认识cpu、核心与线程 java多线程系列（一）之java多线程技能 认识cpu、核心与线程 cpu与核心 物理核 物理核数量=cpu数(机子上装的cpu的数量)*每个cpu的核心数 虚拟核 ● 所谓的4核8线程，4核指的是物理核心。通过超线程技术，用一个物理核模拟两个虚拟核，每个核两个线程，总数为8线程。 ● 在操作系统看来是8个核，但是实际上是4个物理核。 ● 通过超线程技术可以实现单个物理核实现线程级别的并行计算，但是比不上性能两个物理核。 单核cpu和多核cpu
线程基础
gbk_utf8的博客
07-27 188
线程的创建以及线程以及进程的区别
JAVA基础总结（十）之并发编程
m0_37834614的博客
05-21 223
并发编程 进程 什么是进程。操作系统中运行的一个应用程序 例如qq,微信。操作系统都会运行一个进程 每个进程都是独立的，每个进程都运行在其专有且保护的内存空间里面 在windows可以通过任务管理器查看 线程 什么是线程.一个进程想要执行任务。就必须要有线程。 一个进程的所有任务都在线程中执行 一个线程的任务执行是串行的 例如下载一个3个文件。是一个一个下载 多线程 什么是多线程。一个进程可以开启多线程。所有线程可以同时执行不同的任务。叫多线程 例如同时下载多个文件 多线程的原理 在同一时间, cpu的一个
java 创建线程的三种方式、创建线程池的四种方式
SmileTimLi的博客
02-23 4万+
概要： java创建线程的三种方式： 继承Thread类创建线程类 实现Runnable接口 通过Callable和Future创建线程 java创建线程池的四种方式： newCachedThreadPool 创建一个可缓存的线程池，如果线程池长度超过处理需求，可灵活回收空闲线程，若无可回收，则新建线程 newFixedThread...
java线程是有什么组成的_Java 并发知识（1）（线程）
weixin_35891744的博客
02-26 637
1：什么是线程和进程?进程介绍：进程是系统运行程序的基本单位，系统运行一个程序即是一个进程从创建，运行到消亡的过程。(一个进程一个端口号)当我们启动 main 函数时其实就是启动了一个 JVM 的进程，而 main 函数所在的线程就是这个进程中的一个线程，也称主线程。线程介绍：一个进程在其执行的过程中可以产生多个线程。多个线程共享进程的堆和方法区资源，但每个线程有自己的程序计数器、虚拟机栈和本地方...
java_Thread.rar_java 多线程_java多线程
09-21
Java多线程是Java编程中的重要概念，它允许程序同时执行多个任务，从而提高系统资源的利用率和程序的响应速度。在Java中，通过实现Runnable接口或者继承Thread类可以创建并运行多线程。本资料"java_Thread.rar"提供...
clientThread.rar_java 多线程_java 聊天
09-19
下面我们将深入探讨与这个项目相关的Java多线程和聊天应用的知识点。 1. **Java多线程**：在Java中，多线程通过创建线程对象来实现。主要有两种方式，一是继承`Thread`类，二是实现`Runnable`接口。`Thread`类是...
java多线程_java多线程下变量共享_
09-30
Java多线程是Java编程中的重要概念，它允许程序同时执行多个任务，从而提升系统效率。在多线程环境中，变量共享是一个常见的需求，但也是引发问题的关键点。本篇文章将深入探讨Java多线程下变量共享的问题以及解决...
java_type_train.rar_java 多线程_java 打字 程序_train_线程
最新发布
09-23
本资源“java_type_train.rar”提供了一个关于Java多线程和打字程序的训练材料，特别适合想要提升这方面技能的学习者。 多线程在Java中的实现主要有两种方式：通过继承Thread类或实现Runnable接口。当创建一个新...
java多线程编程_java多线程_
09-29
1.讲解了Java多线程的基础， 包括Thread类的核心API的使用。2.讲解了在多线程中对并发访问的控制， 主要就是synchronized的使用， 由于此关键字在使用上非常灵活， 所以书中用了很多案例来介绍此关键字的使用， 为...
线程
weixin_45715461的博客
04-03 275
引入线程的动机： ①Web浏览器：一个线程来显示图像和文本，另一个线程从网络接受数据。 ②字处理软件：一个线程用于显示图形，另一个线程用于响应用户的键盘操作，又可用一个线程在后台进行拼写和语法检查，还可用一个线程在后台定时存盘操作。 ③Web服务器：执行多个类似的任务，可能有多个（可能数百个）客户并发访问它。 多线程结构： 每个正在运行的程序（即进程），至少包括一个线程，这个线程叫主线程。 主线程在程序启动时被创建，用于执行main函数。 只有一个主线程的程序，称作单线程程序。 主线程负责执行程序的所有代码
Java线程(一):线程结构图及状态
SayNight
11-01 5886
线程结构图、线程状态及状态转换图
java 多线程学习（一） 多线程的构造
man_zuo的博客
07-31 1119
进程和线程的理解： 进程：从狭义的角度来讲,进程就是一个正在运行的程序的实例。 线程：指的是进程中单一顺序的执行流，有时候也叫作轻量级进程。 举个例子： 当我们用word 2016程序 编辑word的时候，word2016 可以实时检查拼写的错误。 我们先运行word 2016 程序， 打开任务管理器，切换到进程页面，就可以找到word2016的进程，这就是正在...
Java线程的底层实现
To be a great coder
06-24 5314
前言   我们知道，线程是 CPU 独立调度的单位，通过引入线程，实现时分复用，利用并发思想使得我们的程序运行的更加迅速。 主流的操作系统都提供了线程的实现，注意这句话，谁实现的线程？是操作系统，尽管本文侧重于介绍 Java 线程的实现原理，但是请大家清楚一点，实际上实现线程的老大哥，是运行在内核态的操作系统。 Java 语言提供了不同硬件和操作系统平台下对线程操作的统一处理，每个已经执...
java线程池基本结构原理
彦楠的博客
10-13 2070
1 ThreadPoolExecutor线程池顶级父类Executor interface Executor extends interface ExecutorService implements abstract AbstractExecutorServi...
深入理解Java多线程（一）
热门推荐
qq_37438740的博客
08-11 4万+
关于java多线程的概念以及基本用法：java多线程基础 1，停止线程 停止线程意味着在线程执行完之前停止正在做的操作，即立刻放弃当前的操作，这并不容易。停止线程可以用Thread.stop()方法，但是这个方法不安全，所以不建议使用，还有一个方法就是Thread.interrupt()方法，但是这个方法不会终止一个正在运行的线程，需要添加一个判断才可以完成线程的停止 1.1，...
Java多线程之基础篇（一）
Tomdogs的专栏
07-15 1万+
一、并发和并行 1.1 概念 并行：多个CPU实例或是多台机器同时执行一段处理逻辑，是真正的同时。 并发：通过CUP调度算法，让用户看上去同时去执行，实际上从CPU操作层面并不是真正的同时。并发往往需要公共的资源，对公共资源的处理和线程之间的协调是并发的难点。 1.2 比较   如果你想要一个程序运行的更快，那么可以将其断开为多个片段，在单独的处理器上运行每个片段。并发是用于多...
JAVA线程简介
Robin Hu的专栏
11-11 1180
Thread是程序中的执行线程。Java 虚拟机允许应用程序并发地运行多个执行线程。 每个线程都有一个优先级，高优先级线程的执行优先于低优先级线程。线程可以是守护线程或非守护线程。 当某个线程中运行的代码创建一个新 Thread 对象时，该新线程的初始优先级被设定为创建线程的优先级， 并且默认情况下，当且仅当创建它的线程是守护线程时，新线程才是守护程序。 当 Java 虚拟机启动时，通常都
线程的组成 java 1615387415
pyhui的技术博客
03-10 601
线程的组成 java 1615387415 任何一个线程都具有基本的组成部分 每一个线程都具有自己的栈空间 多个线程共用栈空间的内容
Java多线程：理解线程优先级与创建方式
Java多线程是面向对象程序设计中的重要概念，特别是在第九章中，刘慧老师详细讲解了线程的优先级管理和多线程的基本原理。主要内容包括： 1. 线程优先级： - Java中的线程优先级通过1到10的整数值表示，其中Thread...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

悬浮海

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值