多线程的相关概念以及如何创建多线程

最新推荐文章于 2023-04-01 14:11:30 发布

bfhonor

最新推荐文章于 2023-04-01 14:11:30 发布

阅读量269

点赞数

CC 4.0 BY-SA版权

分类专栏： Java基础文章标签：多线程 java

本文链接：https://blog.csdn.net/qq_44096670/article/details/107435327

Java基础专栏收录该内容

48 篇文章

订阅专栏

本文详细介绍了多线程的概念，包括并发与并行的区别，线程与进程的关系，以及线程调度机制。深入探讨了Java中创建多线程的两种主要方式：继承Thread类和实现Runnable接口，对比了两者的优缺点。

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

一、多线程的相关概念

1.1 并发与并行

并发：指两个或多个事件在同一个时间段内发生。
并行：指两个或多个事件在同一时刻发生（同时发生）。

在操作系统中，安装了多个程序，并发指的是在一段时间内宏观上有多个程序同时运行，这在单 CPU 系统中，每一时刻只能有一道程序执行，即微观上这些程序是分时的交替运行，只不过是给人的感觉是同时运行，那是因为分时交替运行的时间是非常短的。

而在多个 CPU 系统中，则这些可以并发执行的程序便可以分配到多个处理器上（CPU），实现多任务并行执行，即利用每个处理器来处理一个可以并发执行的程序，这样多个程序便可以同时执行。目前电脑市场上说的多核 CPU，便是多核处理器，核越多，并行处理的程序越多，能大大的提高电脑运行的效率。

注意：单核处理器的计算机肯定是不能并行的处理多个任务的，只能是多个任务在单个CPU上并发运行。同理,线程也是一样的，从宏观角度上理解线程是并行运行的，但是从微观角度上分析却是串行运行的，即一个线程一个线程的去运行，当系统只有一个CPU时，线程会以某种顺序执行多个线程，我们把这种情况称之为线程调度。

1.2 线程与进程

进程：是指一个内存中运行的应用程序，每个进程都有一个独立的内存空间，一个应用程序可以同时运行多个进程；进程也是程序的一次执行过程，是系统运行程序的基本单位；系统运行一个程序即是一个进程从创建、运行到消亡的过程。
线程：线程是进程中的一个执行单元，负责当前进程中程序的执行，一个进程中至少有一个线程。一个进程中是可以有多个线程的，这个应用程序也可以称之为多线程程序。

简而言之：一个程序运行后至少有一个进程，一个进程中可以包含多个线程

线程调度:

分时调度：所有线程轮流使用 CPU 的使用权，平均分配每个线程占用 CPU 的时间。
抢占式调度：优先让优先级高的线程使用 CPU，如果线程的优先级相同，那么会随机选择一个(线程随机性)，Java使用的为抢占式调度。
- 设置线程的优先级
- 抢占式调度详解
大部分操作系统都支持多进程并发运行，现在的操作系统几乎都支持同时运行多个程序。比如：现在我们上课一边使用编辑器，一边使用录屏软件，同时还开着画图板，dos窗口等软件。此时，这些程序是在同时运行，”感觉这些软件好像在同一时刻运行着“。

实际上，CPU(中央处理器)使用抢占式调度模式在多个线程间进行着高速的切换。对于CPU的一个核而言，某个时刻，只能执行一个线程，而 CPU的在多个线程间切换速度相对我们的感觉要快，看上去就是在同一时刻运行。
其实，多线程程序并不能提高程序的运行速度，但能够提高程序运行效率，让CPU的使用率更高。

二、创建多线程

2.1 创建多线程程序的第一种方式-创建Thread类的子类

java.lang.Thread类：是描述线程的类，我们想要实现多线程程序，就必须继承Thread类。
实现步骤：
①、创建一个Thread类的子类。
②、在Thread类的子类中重写Thread类的run方法，设置线程任务（开启线程要做什么？）。
③、创建Thread类的子类对象。
④、调用Thread类中的方法start方法，开启新的线程，执行run方法。

Java程序属于抢占式调度，那个线程的优先级高，那个线程优先执行；同一优先级，随机选择一个执行。

//1.创建一个Thread类的子类
class MyThread extends Thread{
    //2.在Thread类的子类重写Thread类中的run方法,设置线程任务(开启线程要做什么？)
    @Override
    public void run(){
        for (int i = 0; i < 20; i++) {
            System.out.println("run:"+i);
        }
    }
}

public class Main{
    public static void main(String[] args) {
        //3.创建Thread类的子类对象
        MyThread mt = new MyThread();
        //4.调用Thread类中的方法start方法,开启新的线程,执行run方法
        mt.start();

        //主线程会继续执行主方法中的代码
        for (int i = 0; i < 20; i++) {
            System.out.println("main:"+i);
        }
    }
}

在这里插入图片描述

2.2 多线程原理

程序启动运行main时候，java虚拟机启动一个进程，主线程main在main()调用时候被创建。随着调用mt的对象的start方法，另外一个新的线程也启动了，这样，整个应用就在多线程下运行。
多线程执行时，在栈内存中，其实每一个执行线程都有一片自己所属的栈内存空间。进行方法的压栈和弹栈。

当执行线程的任务结束了，线程自动在栈内存中释放了。但是当所有的执行线程都结束了，那么进程就结束了。

2.3 Thread类

2.3.1 构造方法：

public Thread() :分配一个新的线程对象。
public Thread(String name) :分配一个指定名字的新的线程对象。

设置线程的名称(了解)：
①、使用Thread类中的方法setName(名字)，void setName(String name) 改变线程名称,使之与参数 name 相同。
②、创建一个带参数的构造方法,参数传递线程的名称,调用父类的带参构造方法,把线程名传递给父类,让父类(Thread)给子线程起一个名字，Thread(Sting name) 分配新的Thread对象

class Demo01GetThreadName{
    public static void main(String[] args) {
        //方法一、开启多线程
        MyThread mt = new MyThread();
        mt.setName("小强");
        mt.start();

        //方法二、2开启多线程
        new MyThread("旺财").start();
    }
}

public class MyThread extends Thread{
	//方法二，1设置构造方法
    public MyThread(){}
    public MyThread(String name){
        super(name);//把线程名传递给父类,让父类(Thread)给子线程起一个名字
    }

    //重写Thread类中的run方法,设置线程任务
    @Override
    public void run(){
        //获取线程名称
        System.out.println(Thread.currentThread().getName());//小强 旺财
    }
}

public Thread(Runnable target) :分配一个带有指定目标新的线程对象。
public Thread(Runnable target,String name) :分配一个带有指定目标新的线程对象并指定名字。

2.3.2 常用方法：

public String getName():获取当前线程名称。
public static Thread currentThread() :返回对当前正在执行的线程对象的引用。

获取线程二点名称：
①、使用Thread类中的方法getName()，String getName()返回该线程的名称。

class Demo01GetThreadName{
    public static void main(String[] args) {
        //创建Thread类的子类对象
        MyThread mt = new MyThread();
        //调用start方法,开启新的线程,执行run()方法
        mt.start();
		new MyThread().start();
        new MyThread().start();
    }
}

//定义一个Thread类的子类
public class MyThread extends Thread{
    //重写Thread类中的run方法,设置线程任务

    @Override
    public void run(){
        //获取线程名称
        String name = getName();
        System.out.println(name);
    }
}
/*线程的名称：
    主线程：main
    新线程：Thread-0,Thread-1,Thread-2*/

②、可以先获取到当前正在执行的线程，使用线程中的方法getName()获取线程的名称

//定义一个Thread类的子类
public class MyThread extends Thread{
    //重写Thread类中的run方法,设置线程任务
    @Override
    public void run(){
        //获取线程名称
        Thread t = Thread.currentThread();
        System.out.println(t);

        String name = t.getName();
        System.out.println(name);
    }
}
运行结果：
Thread[Thread-0,5,main]
Thread-0
Thread[Thread-1,5,main]
Thread-1
Thread[Thread-2,5,main]
Thread-2

public void start():导致此线程开始执行; Java虚拟机调用此线程的run方法。
public void run() :此线程要执行的任务在此处定义代码。
public static void sleep(long millis) :使当前正在执行的线程以指定的毫秒数暂停（暂时停止执行）。

/*毫秒数结束之后线程继续执行*/
class Demo01GetThreadName{
    public static void main(String[] args) {
        //模拟秒表
        for (int i = 1; i <60 ; i++) {
            System.out.println(i);

            //使用Thread类的sleep方法让程序睡眠1秒钟
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

2.4 创建多线程程序的第二种方式-实现Runnable接口

创建多线程程序的第二种方式：实现Runnable接口
java.lang.RunnableRunnable接口应该由那些打算通过某一线程执行其实例的类来实现。类必须定义一个称为run的无参数方法。
java.lang.Thread类的构造方法：
①、Thread(Runnable target):分配新的Thread对象
②、Thread(Runnable target,String name):分配新的Thread对象。
实现步骤：
1.创建一个Runnable接口的实现类
2.在实现类中重写Runnable接口的run方法,设置线程任务
3.创建一个Runnable接口的实现类对象
4.创建Thread类对象,构造方法中传递Runnable接口的实现类对象。
5.调用Thread类中的start方法，开启新的线程执行run方法。

代码如下：

//1.创建一个Runnable接口的实现类
class RunnableImp1 implements Runnable{
    //2.在实现类中重写Runnable接口的run方法,设置线程任务
    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            System.out.println(Thread.currentThread().getName()+"-->"+i);
        }
    }
}

public class MyThread extends Thread{
    public static void main(String[] args) {
        //3.创建一个Runnable接口的实现类对象
        RunnableImp1 run = new RunnableImp1();
        //4.创建Thread类对象,构造方法中传递Runnable接口的实现类对象。
        Thread t = new Thread(run);//打印线程名称
        //5.调用Thread类中的start方法，开启新的线程执行run方法。
        t.start();

        for (int i = 0; i < 20; i++) {
            System.out.println(Thread.currentThread().getName()+"-->"+i);
        }
    }
}
运行结果：
main-->0
main-->1
main-->2
Thread-0-->0
Thread-0-->1
Thread-0-->2
......

通过实现Runnable接口，使得该类有了多线程类的特征。run()方法是多线程程序的一个执行目标。所有的多线程代码都在run方法里面。Thread类实际上也是实现了Runnable接口的类。
在启动的多线程的时候，需要先通过Thread类的构造方法Thread(Runnable target) 构造出对象，然后调用Thread对象的start()方法来运行多线程代码。

2.5 Thread和Runnable的区别

如果一个类继承Thread，则不适合资源共享。但是如果实现了Runable接口的话，则很容易的实现资源共享。
实现Runnable接口创建多线程程序的好处：
①、避免了单继承的局限性，一个类只能继承一个类,类继承了Thread类就不能继承其他的类，实现Runnable接口,还可以继承其他的类,实现其他的接口
②、增强了程序的扩展性,降低了程序的耦合性(解耦)实现Runnable接口的方式,把设置线程任务和开启新线程进行了分离(解耦)；实现类中,重写了run方法,用来设置线程任务；创建Thread类对象,调用start方法,用来开启新线程

//1.创建一个Runnable接口的实现类
class RunnableImp2 implements Runnable{
	//2.在实现类中重写Runnable接口的run方法,设置线程任务
    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            System.out.println("HelloWorld"+i);
        }
    }
}

public class MyThread extends Thread{
    public static void main(String[] args) {
        //3.创建Thread类对象,构造方法中传递Runnable接口的实现类对象。
        Thread t = new Thread(new RunnableImp2());//打印HelloWorld
        //4.调用Thread类中的start方法，开启新的线程执行run方法。
        t.start();

        for (int i = 0; i < 20; i++) {
            System.out.println(Thread.currentThread().getName()+"-->"+i);
        }
    }
}
运行结果：
main-->0
main-->1
HelloWorld0
HelloWorld1
......

③、适合多个相同的程序代码的线程去共享同一个资源。
④、线程池只能放入实现Runable或Callable类线程，不能直接放入继承Thread的类。

2.6 匿名内部类方式实现线程的创建

使用匿名内部类的方式实现Runnable接口，重新Runnable接口中的run方法：
匿名：没有名字。
内部类：写在其他类内的类。

匿名内部类：
①、简化代码，把子类继承父类，重写父类的方法，创建子类对象集合一步完成。
②、把实现类实现接口，重写接口中的方法，创建实现类对象合成一步完成。
匿名内部类的最终产物：子类/实现类对象，而这个类没有名字。
格式：

new 父类/接口(){
	重复父类/接口中的方法
};

示例代码：

public class Demo01InnerClassThread{
    public static void main(String[] args) {
        //线程的父类是Thread
        //new MyThread().start();//子类开启线程
        new Thread(){
            //重写run方法,设置线程任务
            @Override
            public void run(){
                for (int i = 0; i < 2; i++) {
                    System.out.println(Thread.currentThread().getName()+"-->"+"海贼王");
                }
            }
        }.start();

        //线程的接口Runnable
        //Runnable r = new RunnableImpl();//多态
        Runnable r = new Runnable() {
            //重写run方法,设置线程任务
            @Override
            public void run(){
                for (int i = 0; i < 2; i++) {
                    System.out.println(Thread.currentThread().getName()+"-->"+"名侦探柯南");
                }
            }
        };
        new Thread(r).start();

        //简化接口方式
        new Thread(new Runnable() {
            //重写run方法,设置线程任务
            @Override
            public void run(){
                for (int i = 0; i < 2; i++) {
                    System.out.println(Thread.currentThread().getName()+"-->"+"怪盗基德");
                }
            }
        }).start();
    }
}
运行结果：
Thread-0-->海贼王
Thread-0-->海贼王
Thread-1-->名侦探柯南
Thread-1-->名侦探柯南
Thread-2-->怪盗基德
Thread-2-->怪盗基德