Java基础：多线程

最新推荐文章于 2022-02-25 14:18:40 发布
原创 最新推荐文章于 2022-02-25 14:18:40 发布 · 110 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

创造多线程的方法之一：

/**
 *
 * 多线程的创建
 * 方法一：继承于Thread类
 * 1、创建一个继承于Thread类的子类
 * 2、重写Thread类的run() --> 将此线程执行的操作声明在run()中
 * 3、创建Thread类的子类的对象
 * 4、通过此对象调用start()
 *
 * 例子：遍历100以内的所有偶数
 *
 *
 * @author shkstart
 * @create 2021-01-24 20:00
 */

//1、创造一个继承于Thread类的子类
class MyThread extends Thread{

    //2、重写Thread类的run()
    @Override
    public void run() {
        for(int i = 0 ; i <100 ; i++){
            if(i%2 == 0){
                System.out.print(i + " ");
            }
        }
    }
}
public class ThreadTest {
    public static void main(String[] args) {

        //3、创建Thread类的子类的对象
        MyThread t1 = new MyThread();

        //4、通过此对象调用start()
        t1.start();

        //多线程的表示:与t1.start()的结果交叉执行⭐
        for(int i = 0 ; i <100 ; i++){
            if(i%2 == 0){
                System.out.print(i + "***** main() ");
            }
        }
    }
}

创建过程中两个问题的说明

//1、创造一个继承于Thread类的子类
class MyThread extends Thread{

    //2、重写Thread类的run()
    @Override
    public void run() {
        for(int i = 0 ; i <100 ; i++){
            if(i%2 == 0){
                //System.out.print(i + " ");
                System.out.println(Thread.currentThread().getName() + ":");
            }
        }
    }
}
public class ThreadTest {
    public static void main(String[] args) {

        //3、创建Thread类的子类的对象
        MyThread t1 = new MyThread();


        //14、创建过程中两个问题的说明

        //4、通过此对象调用start()
        /*
		⭐
        //问题二：
        start()方法的作用
        1、启动当前线程
        2、调用当前线程的run()

         */
        //start表示新建一个线程
        t1.start();//Thread.currentThread().getName():Thread

        t1.run();//Thread.currentThread().getName():main
		//⭐
        //问题二 ： 再启动一个线程，遍历100以内的偶数
        t1.start();//Exception in thread "main" java.lang.IllegalThreadStateException
        MyThread t2 = new MyThread();
        t2.start();


        //多线程的表示:与t1.start()的结果交叉执行
        //如下的操作仍然在main线程中执行的
        for(int i = 0 ; i <100 ; i++){
            if(i%2 == 0){
                //System.out.print(i + "***** main() ");
                System.out.println(Thread.currentThread().getName() + ":");
            }
        }
    }
}

练习1：

package com.atguigu.exer;

/**
 * 练习：
 * 创建两个分线程
 * 其中一个线程遍历100以内的偶数
 * 另一个线程遍历100以内的奇数
 *
 *
 * @author shkstart
 * @create 2021-01-24 20:41
 */


public class ThreadDemo15 {
    public static void main(String[] args) {
//        MyThread1 t1 = new MyThread1();
//        t1.start();
//        MyThread2 t2 = new MyThread2();
//        t2.start();

        /*
        
        方法二：
        
         */
        //创建Thread类的匿名子类的方式
        new Thread(){
            @Override
            public void run() {
                for(int i = 0 ; i < 100 ; i++) {
                    if(i % 2 == 0){
                        System.out.println(i + Thread.currentThread().getName());
                    }
                }
            }
        }.start();

        new Thread(){
            @Override
            public void run() {
                for(int i = 0 ; i < 100 ; i++) {
                    if(i % 2 != 0){
                        System.out.println(i + Thread.currentThread().getName());
                    }
                }
            }
        }.start();

    }
}

//方法1：造两个类
class MyThread1 extends Thread{
    @Override
    public void run() {
        for(int i = 0 ; i < 100 ; i++) {
            if(i % 2 == 0){
                System.out.println(i + Thread.currentThread().getName());
            }
        }
    }
}

class MyThread2 extends Thread{
    @Override
    public void run() {
        for(int i = 0 ; i < 100 ; i++) {
            if(i % 2 != 0){
                System.out.println(i + Thread.currentThread().getName());
            }
        }
    }
}

Thread类的常用方法

package com.atguigu.java;

/**
 *
 * Thread类的常用方法：
 * 1 void start(): 启动线程，并执行对象的run()方法
 *
 * 2 run(): 线程在被调度时执行的操作
 *      通常需要重写Thread类中的此方法，讲创建的线程要执行的操作声明在此方法中
 *
 * 3 String getName(): 返回线程的名称
 *
 * 4 void setName(String name):设置该线程名称
 *
 * 5 static Thread currentThread(): 返回当前线程。在Thread子类中就是this，通常用于主线程和Runnable实现类
 *
 * 6 static void yield()：线程让步
 *      暂停当前正在执行的线程，把执行机会让给优先级相同或更高的线程
 *      若队列中没有同优先级的线程，忽略此方法
 *
 * 7 join() ：当某个程序执行流中调用其他线程的 join() 方法时，调用线程将被阻塞，直到 join() 方法加入的 join 线程执行完为止
 *      低优先级的线程也可以获得执行
 *      当线程 a 中 执行 b.join()方法那么直到 b 执行结束之后 a才开始执行
 *
 * 8 static void sleep(long millis)：(指定时间:毫秒) 令当前活动线程在指定时间段内放弃对CPU控制,使其他线程有机会被执行,时间到后重排队。
 *      抛出InterruptedException异常
 *
 * 9 stop(): 强制线程生命期结束，不推荐使用
 *      已经过时
 *      用 sleep()来代替
 *      sleep(i) 表示线程堵塞 i 秒
 *
 * 10 boolean isAlive()：返回boolean，判断线程是否还活着
 *
 * @author shkstart
 * @create 2021-01-24 21:05
 */
public class ClassThreadMeans16 {
    public static void main(String[] args) {
        //通过setName()命名
        HelloThread t1 = new HelloThread("Thread: 1");
        t1.setName("线程一");
        t1.start();

        //通过构造器命名
        HelloThread t2 = new HelloThread("Thread: 2");
        t2.start();

        //给主线程命名
        Thread.currentThread().setName("主线程");
        for(int i = 1 ; i < 50 ; i++){//主线程主导
            if(i % 2 == 0 ){
                System.out.println(i + Thread.currentThread().getName());
            }
//join()测试
            if(i == 20){
                try {
                    t1.join();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }

            if(i == 20){
                try {
                    t2.join();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }


    }
}

class HelloThread extends Thread{
    @Override
    public void run() {
        for(int i = 1 ; i < 50 ; i++){
            if(i % 2 == 0 ){
//sleep()测试

                try {
                    sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

                System.out.println(i + Thread.currentThread().getName());
            }



//yield()测试
            //this代表HelloThread的对象
            if(i % 20 == 0){

                //yield()表示 ： 释放当前线程，让另一个线程工作
            this.yield();
            //yield();

        }
        }
    }

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

}

线程优先级的设置

package com.atguigu.java;

/**
 *
 * 线程的优先级
 * 1、
 * MAX_PRTORITY:10
 * MIN_PRIORITY:1
 * MORM_PRIORITY:5
 *
 * 2、如何获取和设置当前线程的优先级
 *      getPriority();
 *      setPriority(int p);
 *
 * 高优先级只是可能先执行，但是并不是先执行
 *
 * @author shkstart
 * @create 2021-01-24 21:56
 */
public class Thread17 {
    public static void main(String[] args) {
        Thread3 t3 = new Thread3();
        //在运行之前设置线程的优先级
        t3.setPriority(Thread.MAX_PRIORITY);
        t3.start();

        for(int i = 1; i < 50; i++) {
            if (i % 2 == 0) {
                System.out.println(i + Thread.currentThread().getName() + "、" + Thread.currentThread().getPriority());
            }
        }

    }

}


class Thread3 extends Thread {
    @Override
    public void run() {
        for (int i = 1; i < 50; i++) {
            if (i % 2 == 0) {
                System.out.println(i + Thread.currentThread().getName() + "、" + Thread.currentThread().getPriority());
            }
        }
    }
}

练习2

package com.atguigu.exer;

import sun.applet.Main;

import java.awt.*;

/**
 * 例子：创建三个窗口买票，总票数为100张
 *
 *
 * @author shkstart
 * @create 2021-01-24 22:25
 */
public class Thread18 {
    public static void main(String[] args) {
        window w1 = new window();
        window w2 = new window();
        window w3 = new window();

        w1.setName("窗口1");
        w2.setName("窗口2");
        w3.setName("窗口3");

        w1.start();
        w2.start();
        w3.start();
    }


}

class window extends Thread{
    //static 让所有对象共享⭐
    private static int ticket = 100;

    @Override
    public void run() {

        while(true){

            if(ticket > 0){
                System.out.println(getName() + ": 买票，票号为" + ticket);
                ticket--;
            }
            else{
                break;
            }

        }
    }
}

创造多线程的方法之二：实现Runnable接口

package com.atguigu.java;

/**
 * 创造多线程的方法之二：实现Runnable接口
 * 1、创建一个实现了Runnable接口的类
 * 2、实现类去实现Runnable中的抽象方法：run()
 * 3、创造实现类的对象
 * 4、将此对象作为参数传递到Thread类的构造器中，创造Thread类的对象
 * 5、通过Thread类的对象调用start()
 *
 * @author shkstart
 * @create 2021-01-24 22:40
 */
public class Thread19 {
    public static void main(String[] args) {
        //3、创造实现类的对象
        Thread4 mThread = new Thread4();
        //4、将此对象作为参数传递到Thread类的构造器中，创造Thread类的对象
        Thread t1 = new Thread(mThread);
        //5、通过Thread类的对象调用start()
        t1.start();

        //再启动一个线程
        Thread t2 = new Thread(mThread);
        t2.start();
    }
}
//1、创建一个实现了Runnable接口的类
class Thread4 implements Runnable{
//2、实现类去实现Runnable中的抽象方法：run()
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            if(i % 2 == 0){
                System.out.println(Thread.currentThread().getName()+ ":" + i);
            }
        }
    }
}

练习3

package com.atguigu.exer;

/**
 * @author shkstart
 * @create 2021-01-24 23:34
 */
public class Thread20 {
    public static void main(String[] args) {
        myThread mthread = new myThread();
        Thread t1 = new Thread(mthread);
        t1.setName("1");
        Thread t2 = new Thread(mthread);
        t2.setName("2");
        Thread t3 = new Thread(mthread);
        t3.setName("3");

        t1.start();
        t2.start();
        t3.start();
    }

}

class myThread implements Runnable{
    private int ticket = 100;

    @Override
    public void run() {
        while(true){
            if(ticket > 0){
                System.out.println("窗口" + Thread.currentThread().getName() + "卖票:剩余票数" + ticket);
                ticket--;
            }
            else{
                break;
            }
        }
    }
}

两种方式的对比

在开发中：优先选择实现Runnable接口的方式
原因：
1、实现方式没有继承类的局限性
2、实现的方式更适合来处理多个线程有共享数据的情况。

联系：public class Thread implements Runnable

相同点：两种方式都需要重写run(),将线程要执行的逻辑声明在run()中

Camellia0212
关注
Java零基础之多线程篇：多线程最佳实践
喵手的博客
08-01 2150
在计算机科学领域，多线程是一种重要的编程概念。它允许程序同时执行多个任务，提高了程序的并发性和响应性。对于Java开发者而言，了解和掌握多线程编程是非常重要的一项技能。本文将从零基础开始介绍Java多线程的概念和用法，帮助读者理解多线程的原理和实践技巧。我们将深入探讨多线程的最佳实践，包括源代码解析、应用场景案例、优缺点分析和具体的Java代码测试用例。本文将带领读者逐步学习Java多线程编程的基础知识和高级概念。我们将通过详细的源代码解析和实际应用场景案例，帮助读者理解多线程的内部工作原理和使用技巧。
《Java多线程并发编程：解锁线程安全的奥秘》
09-08
适合人群：具备一定Java基础，从事开发工作1-3年，希望深入理解多线程与并发编程原理的中初级研发人员；也适合准备面试或系统性提升并发编程能力的开发者。 使用场景及目标：①掌握多线程创建、状态控制与线程安全...
多线程基础
weixin_45966976的博客
06-05 697
Thread的基本概念:程序,进程,线程一、基本含义:二、代码完成继承Thread的方式创建分线程,并遍历100以内的自然数三、代码完成实现Runnable接口的方法创建分线程,并且遍历100以内的自然数四、对比两种创建方式五、Thread中常用的方法测试Thread中常用的方法线程的优先级:六、三个窗口一共卖100张票实现Runnable接口继承Thread方法七、线程的生命周期功能快捷键合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表
Java-day18（多线程）
weixin_44742328的博客
09-24 295
程序、进程、线程的定义 每个线程都有一套虚拟机栈和程序计数器，而方法区和堆只有一个进程才有一套，所以方法区和堆是进程里面线程共享的，例如堆里面提供了一个实例变量每个线程都可以去修改。 ...
多线程（一）
weixin_45569897的博客
08-24 225
一、线程线程代码完成继承Thread的方式创建分线程，并遍历100以内的自然数代码完成实现Runnable接口的方法创建分线程，并遍历100以内的自然数对比两种创建方式总结欢迎使用Markdown编辑器新的改变功能快捷键合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchar
java 多线程之继承Thread类实现创建多线程及实现Runnable接口创建多线程
码农回顾
11-23 2495
java 多线程之继承Thread类实现创建多线程1.Java 多线程之Thread类2.继承Thread类实现创建多线程3.Thread类常用的方法 1.Java 多线程之Thread类 Java语言的JVM允许程序运行多个线程，它通过java.lang.Thread类来实现。 Thread类的特性 ① 每个线程都是通过某个特定Thread对象的run()方法来完成操作的，经常把run(...
java多线程之创建线程的两种方式（继承Thread类，实现Runnable接口）
高度不够看到的都是问题，格局太小纠结的都是鸡毛蒜皮。
05-19 694
如果还不是很了解java中的多线程是什么可以参考我的这篇博客： 线程的概述 如和通过Thread类来创建一个线程 通过一个例子来实现： 创建子线程，完成1-10自然数的输出，主线程也同样完成1-10自然数的输出 package com.ghl.demo; /**创建线程的第一种方式 * 创建子线程，完成1-10自然数的输出，主线程也同样完成1-10自然数的输出 */ public clas...
java基础：多线程学习笔记
11-14
在Java中，多线程是一种同时执行多个线程来完成特定任务的技术，这对于提高程序的效率和响应性非常重要。在Java的多线程学习笔记中，通常会涉及到以下几个核心知识点： 1. **多线程的概念**：多线程是指在单个进程...
精选资源
极简JAVA七：多线程与网络编程
06-19
在Java编程领域，多线程和网络编程是两个至关重要的概念，它们对于构建高效、可扩展的现代应用程序至关重要。在"极简JAVA七：多线程与网络编程"的学习资源中，你将深入理解这两个核心主题，从而提升你的Java开发技能...
Java 软件设计基础:Java线程机制
03-31
Java 软件设计基础中，Java 线程机制是指在 Java 中实现多线程编程的机制。多线程编程是指在单个程序中可以同时运行多个不同的线程，执行不同的任务，这是实现并发机制的一种有效手段。 线程的基本概念 在 Java 中...
通过继承Thread类的方式创建两个线程
热门推荐
:)一位靓仔偶然路过的博客
09-30 1万+
8、通过继承Thread类的方式创建两个线程，在Thread构造方法中指定线程的名字，并将这两个线程的名字打印出来。 public class MyThread extends Thread{ public MyThread(String name) { super(name); } public void run() { System.ou
（尚硅谷java零基础教程）学习笔记day17-每日一考
qq_42148002的博客
02-25 366
1. 谈谈你对程序、进程、线程的理解 程序：是为完成特定任务、用某种语言编写的一组指令的集合。即指一段静态的代码，静态对象。 进程：是程序的一次执行过程，或是正在运行的一个程序。 线程：进程可进一步细化为线程，是一个程序内部的一条执行路径。 2. 代码完成继承Thread的方式创建分线程，并遍历100以内的自然数 多线程的创建：方式一：继承于Thread类 1.创建一个继承于Thread类的子类 2.重写Thread类的run()方法 ----> 将此线程执行的操作声明在run()方法中 3.创建子类
Java（通过继承Thread类的方式创建两个线程，在Thread构造方法中指定线程的名字“线程一”、“线程二”，并将这两个线程的名字打印出来。）
爱学习的JackYang的博客
11-30 8416
public class Double { public static void main(String[] args){ Mythread one=new Mythread(); Mthread two=new Mthread(); one.setName("线程一"); two.setName("线程二"); one.start(); two.start(); }...
Day64.多线程练习2 -Java多线程
阿昌爱Java
10-07 367
1. 谈谈你对程序、进程、线程的理解 程序: 为完成特定任务，用某一种语言编写的指令集合；一段静态的代码 进程: 正在运行的程序 线程: 程序内部中的一条执行路径 2. 代码完成继承Thread的方式创建分线程，并遍历100以内的自然数与代码完成实现Runnable接口的方法创建分线程，并遍历100以内的自然数 /**两种方式方式实现遍历100以内的自然数 * @author 阿昌 * @create 2020-10-07 12:29 */ //方式一:继承Thread类的方式 class OThr
java多线程（2）----继承的方式创建多线程
xd1501013的博客
06-10 302
文章目录1.单线程举例2.多线程的创建与启动3.实例4.需要注意的地方5.参考资料 1.单线程举例 public class Test { public static void main(String[] args){ method2("yyzhang"); } public static void method1(String str){ System.out....
【AutoHotKey】基于 Bark 推送服务的 Windows Handoff 剪贴板支持工具，解决跨设备同步痛点！.zip
12-31
【AutoHotKey】基于 Bark 推送服务的 Windows Handoff 剪贴板支持工具，解决跨设备同步痛点！.zip
从营收增长承压到区域创新生态能级跃升，政府部门借助需求牵引型技术经纪服务能实现多大跨越？.docx
12-31
从营收增长承压到区域创新生态能级跃升，政府部门借助需求牵引型技术经纪服务能实现多大跨越？
【C 语言】基于 AT89C51 单片机的电梯程序控制系统（高效响应楼层请求，源码可复用）.zip
最新发布
12-31
【C 语言】基于 AT89C51 单片机的电梯程序控制系统（高效响应楼层请求，源码可复用）.zip
如何利用闭环的新一代成果转化SaaS解决市场化技术转移机构面临的市场竞争加剧难题？.docx
12-31
如何利用闭环的新一代成果转化SaaS解决市场化技术转移机构面临的市场竞争加剧难题？
Java基础：多线程、去重与并发编程实用技巧
本资源主要涵盖了Java基础、多线程和数据处理等方面的内容，重点讨论了以下几个关键知识点： 1. **Java基础**： - 实现Runnable接口和Callable接口：Java中的多线程可以通过实现Runnable接口或继承Thread类，以及...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值