多线程的创建和使用

最新推荐文章于 2022-12-29 12:08:39 发布
最新推荐文章于 2022-12-29 12:08:39 发布
阅读量161 收藏
点赞数 1
分类专栏： java提高部分学习笔记 文章标签： 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41005604/article/details/107428305
版权

线程的创建和使用

Java语言的JVM允许程序运行多个线程，它通过java.lang.Thread 类来体现。

API中创建线程的两种方式之一（继承Thread类 ）

  • 每个线程都是通过某个特定Thread对象的run()方法来完成操作的，经常 把run()方法的主体称为线程体
  • 通过该Thread对象的start()方法来启动这个线程，而非直接调用run()

Thread类

构造器

  • Thread()：创建新的Thread对象
  • Thread(String threadname)：创建线程并指定线程实例名
  • Thread(Runnable target)：指定创建线程的目标对象，它实现了Runnable接 口中的run方法
  • Thread(Runnable target, String name)：创建新的Thread对象

继承Thread类

  1. 定义子类继承Thread类。
  2. 子类中重写Thread类中的run方法。
  3. 创建Thread子类对象，即创建了线程对象。
  4. 调用线程对象start方法：启动线程，调用run方法。
注意点
  1. 如果自己手动调用run()方法，那么就只是普通方法，没有启动多线程模式。
  2. run()方法由JVM调用，什么时候调用，执行的过程控制都有操作系统的CPU
    调度决定。
  3. 想要启动多线程，必须调用start方法。
  4. 一个线程对象只能调用一次start()方法启动，如果重复调用了，则将抛出以上 的异常“IllegalThreadStateException”。
/**
 * 多线程的创建，方式一：继承于Thread类
 * 1. 创建一个继承于Thread类的子类
 * 2. 重写Thread类的run() --> 将此线程执行的操作声明在run()中
 * 3. 创建Thread类的子类的对象
 * 4. 通过此对象调用start()
 * <p>
 * 例子：遍历100以内的所有的偶数
 *
 */

//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.println(Thread.currentThread().getName() + ":" + i);
            }
        }
    }
}


public class ThreadTest {
    public static void main(String[] args) {
        //3. 创建Thread类的子类的对象
        MyThread t1 = new MyThread();

        //4.通过此对象调用start():①启动当前线程 ② 调用当前线程的run()
        t1.start();
        //问题一：我们不能通过直接调用run()的方式启动线程。
//        t1.run();

        //问题二：再启动一个线程，遍历100以内的偶数。不可以还让已经start()的线程去执行。会报IllegalThreadStateException
//        t1.start();
        //我们需要重新创建一个线程的对象
        MyThread t2 = new MyThread();
        t2.start();


        //如下操作仍然是在main线程中执行的。
        for (int i = 0; i < 100; i++) {
            if(i % 2 == 0){
                System.out.println(Thread.currentThread().getName() + ":" + i + "***********main()************");
            }
        }
    }

}

练习：创建两个分线程，其中一个线程遍历100以内的偶数，另一个线程遍历100以内的奇数

public class ThreadDemo {
    public static void main(String[] args) {
        MyThread1 m1 = new MyThread1();
        MyThread2 m2 = new MyThread2();

        m1.start();
        m2.start();


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

            }
        }

    }
}


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

            }
        }

    }
}

匿名内部类的方式（一般情况下这个对象之后都不会用了就用匿名内部类的方式）

public class ThreadDemo {
    public static void main(String[] args) {
        //创建Thread类的匿名子类的方式
        new Thread(){
            @Override
            public void run() {
                for (int i = 0; i < 100; i++) {
                    if(i % 2 == 0){
                        System.out.println(Thread.currentThread().getName() + ":" + i);

                    }
                }
            }
        }.start();


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

                    }
                }
            }
        }.start();

    }
}

Thread类的有关方法

常用方法

  1. start():启动当前线程；调用当前线程的run()
  2. run(): 通常需要重写Thread类中的此方法，将创建的线程要执行的操作声明在此方法中
  3. currentThread():静态方法，返回执行当前代码的线程
  4. getName():获取当前线程的名字
  5. setName():设置当前线程的名字
  6. yield():释放当前cpu的执行权（当然了有可能在下一刻又分配给当前这个线程了，所以看起来容易认为没有作用）
  7. join():在线程a中调用线程b的join(),此时线程a就进入阻塞状态，直到线程b完全执行完以后，线程a才结束阻塞状态。
  8. stop():已过时。当执行此方法时，强制结束当前线程。
  9. sleep(long millitime):让当前线程“睡眠”指定的millitime毫秒。在指定的millitime毫秒时间内，当前线程是阻塞状态。
  10. boolean isAlive():判断当前线程是否存活。

线程的优先级

1.线程的优先级

  • MAX_PRIORITY：10
  • MIN _PRIORITY：1
  • NORM_PRIORITY：5 -->默认优先级

2.如何获取和设置当前线程的优先级：

  • getPriority():获取线程的优先级
  • setPriority(int p):设置线程的优先级
  • 说明：高优先级的线程要抢占低优先级线程cpu的执行权。但是只是从概率上讲，高优先级的线程高概率的情况下被执行。并不意味着只有当高优先级的线程执行完以后，低优先级的线程才执行。
class HelloThread extends Thread{
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            if(i % 2 == 0){

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

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

//            if(i % 20 == 0){
//                yield();
//            }

        }

    }
    
    //构造器给线程命名
    public HelloThread(String name){
        super(name);
    }
}


public class ThreadMethodTest {
    public static void main(String[] args) {
    	
    	//构造器给线程命名
        HelloThread h1 = new HelloThread("Thread：1");

//        h1.setName("线程一");
        //设置分线程的优先级
        h1.setPriority(Thread.MAX_PRIORITY);

        h1.start();

        //给主线程命名
        Thread.currentThread().setName("主线程");
        Thread.currentThread().setPriority(Thread.MIN_PRIORITY);

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

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

        }

//        System.out.println(h1.isAlive());

    }
}

练习：（为了引入第二种创建线程的方式）

例子：创建三个窗口卖票，总票数为100张.使用继承Thread类的方式

/**
 *
 * 例子：创建三个窗口卖票，总票数为100张.使用继承Thread类的方式
 *
 * 存在线程的安全问题，待解决。
 *
 */
class Window extends Thread{

	//用static设置成静态的，不然三个对象每个对象都有100张票，就买了300张
    private static int ticket = 100;
    @Override
    public void run() {

        while(true){

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

        }

    }
}


public class WindowTest {
    public static void main(String[] args) {
        Window t1 = new Window();
        Window t2 = new Window();
        Window t3 = new Window();


        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");

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

    }
}

API中创建线程的两种方式之二（实现Runnable接口 ）

创建多线程的方式二：实现Runnable接口

  1. 定义子类，实现Runnable接口。
  2. 子类中重写Runnable接口中的run方法。
  3. 通过Thread类含参构造器创建线程对象。
  4. 将Runnable接口的子类对象作为实际参数传递给Thread类的构造器中。
  5. 调用Thread类的start方法：开启线程，调用Runnable子类接口的run方法。
//1. 创建一个实现了Runnable接口的类
class MThread 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);
            }

        }
    }
}


public class ThreadTest1 {
    public static void main(String[] args) {
        //3. 创建实现类的对象
        MThread mThread = new MThread();
        //4. 将此对象作为参数传递到Thread类的构造器中，创建Thread类的对象
        Thread t1 = new Thread(mThread);
        t1.setName("线程1");
        //5. 通过Thread类的对象调用start():① 启动线程 ②调用当前线程的run()-->调用了Runnable类型的target的run()
        t1.start();

        //再启动一个线程，遍历100以内的偶数
        Thread t2 = new Thread(mThread);
        t2.setName("线程2");
        t2.start();
    }

}

比较创建线程的两种方式

开发中：优先选择：实现Runnable接口的方式

原因：

  1. 实现的方式没有类的单继承性的局限性
  2. 实现的方式更适合来处理多个线程有共享数据的情况。

联系：public class Thread implements Runnable
相同点：两种方式都需要重写run(),将线程要执行的逻辑声明在run()中。

练习：（第二种创建线程的方式）

例子：创建三个窗口卖票，总票数为100张.使用实现Runnable接口的方式
存在线程的安全问题，待解决

class Window1 implements Runnable{
	//这种方式不需要static也是100张票（因为只有一个对象）
    private int ticket = 100;

    @Override
    public void run() {
        while(true){
            if(ticket > 0){
                System.out.println(Thread.currentThread().getName() + ":卖票，票号为：" + ticket);
                ticket--;
            }else{
                break;
            }
        }
    }
}


public class WindowTest1 {
    public static void main(String[] args) {
        Window1 w = new Window1();

        Thread t1 = new Thread(w);
        Thread t2 = new Thread(w);
        Thread t3 = new Thread(w);

        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");

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

}
qq_41005604
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
线程创建和管理
01-15
线程创建和管理是多线程编程中一个非常重要的概念，在实际开发中，合理地创建和管理线程可以提高程序的效率和性能。在C#中，线程池和Thread类是两种常用的线程创建和管理方式。 一、线程池（ThreadPool） 线程池是...
vs2013创建多线程教程
10-17
在 VS2013 平台中，创建多线程可以使用 CreateThread 函数或 AfxBeginThread 函数。 1. 创建线程结构体 首先，需要定义一个线程结构体，用于存储线程的相关信息。例如： ```cpp typedef struct ThreadInfo { ...
创建多线程应用程序
『 李天平的博客 』
03-07 1966
    由于前段时间一直在做银电联网的项目，其中用到了多线程，和基于Socket底层通讯的一些基本技术，自己忙里抽闲总结一下，放在这里。前面已经贴了Socket的基本编程要点和步骤，这里继续贴一下多线程的基本知识。定义名称空间　　在.NET中，多线程功能是在System.Threading名称空间中定义的。using System.Threading;启动线程　　System.threading名
多线程(线程的创建和使用)
weixin_52641674的博客
10-26 162
创建线程的两种方式 方式一：继承Thread类 1) 定义子类继承Thread类。 2) 子类中重写Thread类中的run方法。 3) 创建Thread子类对象，即创建了线程对象。 4) 调用线程对象start方法：①启动当前线程 ②调用当前线程的run() 例：遍历0到100的所有偶数 //1.创建一个继承于Thread类的子类 class MyThread extends Thread { //2.重...
【Java笔记】多线程的创建与使用（Thread与Runnable）
lijibai_的博客
03-29 721
Java 语言的 JVM 允许运行多个线程，它通过 java . lang . Thread 类来体现。 目录 多线程的创建方式一：继承Thread类 多线程的创建方式二：实现Runnable接口 线程的常用方法 线程优先级的设置 Java 中给出的优先级 如何获取和设置当前线程的优先级 多线程的创建方式一：继承Thread类 每个线程都是通过某个特定的 Thread 对象的 run（）方法来完成操作的，经常把 run（）方法的主体称为线程体 通过该 Thread 对象的 start
多线程的4种创建与使用
Yellow_Star的博客
06-29 197
多线程的创建 创建一个继承于Thread的子类 重写Thread中的run方法 ----> 将此线程需要执行的程序写到run方法中 新建一个继承于Thread的子类的对象 调用此对象的start方法 用代码做一个小例子，遍历100以内的偶数 //1.创建一个继承于Thread的子类 class Test extends Thread{ //2.重写Thread类中的run方法 ---> 将此线程所执行的操作，写在run方法中 @Override public
Java使用Thread创建多线程并启动操作示例
08-27
### 多线程创建与启动基础 在Java中，创建线程的最直接方式是继承Thread类，并重写其run()方法，该方法包含了线程执行时所需的代码。创建Thread类的子类后，可以实例化这个子类并调用start()方法来启动线程。start...
qt websocket 客户端 多线程使用
09-16
qt 使用QWebSocket 创建websocket客户端来读取数据，异步链接，并且放入到线程中去执行，线程池的基础，代码使用两个用户，放入到一个线程中执行，同理，可以多个用户放入到多个线程中执行，为线程池执行websocket ...
C# Winform线程创建子窗体
01-21
在C# Winform开发中，多线程技术是不可或缺的一部分，尤其当涉及到用户界面(UI)的异步操作时。线程允许程序同时执行多个任务，提高应用的响应性和效率。本话题将深入探讨如何利用线程来延迟创建子窗体，并且如何安全...
多线程（二）：线程的创建和使用
RufyHuang的博客
02-02 130
文章目录
多线程的创建和使用（4种）
最新发布
lucky_fd的博客
12-29 496
方式一：继承于Thread类 方式二：实现Runnable接口 方式三：实现Callable接口 方式四：使用线程池 进程可以细化为多个线程。 每个线程，拥有自己独立的： 栈、程序计数器。 多个线程，共享同一个进程中的结构：方法区、堆。 并行与并发 并行：多个CPU同时执行多个任务。比如:多个人同时做不同的事 并发：一个CPU(采用时间片)同时执行多个任务。比如:秒杀、多个人做同一件事
多线程--02--线程的创建和使用
时光里的博客
11-16 529
线程的创建和使用 继承于Thread类 实现Runnable接口 Callable Pool 方式一：继承于Thread类 创建一个继承于Thread类的子类 重写Thread类的run() --> 将此线程执行的操作声明在run()中 创建Thread类的子类的对象 通过此对象调用start() 例子： 遍历100以内的所有的偶数 class MyThread extends Thread { @Override public void run() {
Java中多线程的创建和使用
mumihahaha的博客
03-15 210
一、基本概念：程序-进程-线程程序（program）：是为完成特定任务、用某种语言编写的一组指令的集合。即指一段静态的代码，静态对象。进程（process）：是程序的一次执行过程， 或是正在运行的一个程序。动态过程：有它自身的产生、存在和消亡的过程。    &gt;如：运行中的QQ,运行中的MP3播放器    &gt;程序是静态的，进程是动态的线程（thread）：进程可进一步细化为线程，是一个程...
java 多线程创建及应用
Growing_hacker的博客
09-30 219
java 多线程创建的三种方式 1：estends Thread 类 2：implements Runnable 接口 3：new Thread（Runnable接口实现类） 最常用第二种方式，类可以实现多个接口，类只能继承一个父类 实现Runnable接口的实现对象，当被多次start会创建多个多个线程执行，共享成员变量，造成线程不安全问题。 解决方式：一种同步代码块，一种同步方法，一种锁对象 ...
多线程之一 线程的创建与使用
mitays的博客
04-01 119
目录一、本章主旨二、线程的状态 一、本章主旨 常见的线程实现方法有如下四种： 继承Thread并重写run方法； 实现Runnable接口并重写run方法，将其实例作为形参传入Thread构造； 通过Callable和Future Task创建线程； 线程池创建管理线程； 后序将对每一种方法实践，并分析其利弊； 二、线程的状态 ...
多线程创建和使用
Small_dian的专栏
05-09 622
1 编写线程函数 2 建立多线程句柄 3 在测试函数中直接使用线程：挂起，恢复，结束等 线程方法： static unsigned _stdcall sleepTest2(void *param)//函数返回值类型以及函数参数类型需要匹配 { int count = 2; DWORD exitCode = 0; while(1) { Sleep(1500); cou
多线程的创建方式和运行状态
faozhe
05-08 326
一：线程和进程的区别 进程是所有线程的集合，每一个线程是进程中的一条执行路径； 二：创建线程的三种方式 1.继承Thread类 重写run方法 class CreatThread extends Thread { public void run() { for (int i = 0; i < 100; i++) { System.out.println("...
多线程编程实践与创建教程
"多线程编程是一种并发处理技术，它允许在单个程序中同时执行多个任务，以提高系统的效率和响应能力。在C语言中，如给出的代码片段所示，`main`函数通过使用POSIX线程库（pthread）实现了多线程。函数`pthread_...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值