Java多线程的常见创建方式与区别、以及同步问题

最新推荐文章于 2023-03-23 18:40:54 发布

原创最新推荐文章于 2023-03-23 18:40:54 发布 · 242 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#java #多线程

Java 专栏收录该内容

29 篇文章

订阅专栏

本文详细介绍了并发与多线程的概念，包括并发、并行、进程、线程的区别，以及多线程的实现方法，如继承Thread类和实现Runnable接口。探讨了线程调度、资源分配和线程安全问题。

创建线程方法：

方法一：继承Thread类来创建并启动多线程

定义Thread类的子类，并重写该类的run()方法，该run()方法的方法体就代表了线程需要完成的任务,因此把 run()方法称为线程执行体
创建Thread子类的实例，即创建了线程对象
调用线程对象的start()方法来启动该线程
有关Thread类
常用构造方法：
public Thread() :分配一个新的线程对象。
public Thread(String name) :分配一个指定名字的新的线程对象。
public Thread(Runnable target) :分配一个带有指定目标新的线程对象。
public Thread(Runnable target,String name) :分配一个带有指定目标新的线程对象并指定名字。
常用方法：
public String getName() :获取当前线程名称。
public void start() :导致此线程开始执行; Java虚拟机调用此线程的run方法。
public void run() :此线程要执行的任务在此处定义代码。 public
static void sleep(long millis) :使当前正在执行的线程以指定的毫秒数暂停（暂时停止执行）。
public static Thread currentThread() :返回对当前正在执行的线程对象的引用。

代码如下：
测试类：


public class TestThread {
    public static void main(String[] args) {
        //创建自定义线程对象firstThread
        FirstThread firstThread = new FirstThread("myFirstThread");
        //开启新线程firstThread
        firstThread.start();
        //主线程中的方法
        for (int i = 0; i < 5; i++) {
            System.out.println("main线程正在执行"+i);
        }
    }
}

自定义线程类：

public class FirstThread extends Thread {
    //定义指定线程名称的构造方法
    public FirstThread(String name) {
        super(name);
    }

    /**
     * 重写run方法，定义线程要执行的代码，如不重写，则该线程什么都不执行
     */
    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println(getName()+":正在执行"+i);
        }
    }
}

结果：
在这里插入图片描述
分析：
程序执行的流程图：

方法二：利用 java.lang.Runnable接口

步骤如下：

定义Runnable接口的实现类，并重写该接口的run()方法，该run()方法的方法体同样是该线程的线程执行体。
创建Runnable实现类的实例，并以此实例作为Thread的target来创建Thread对象，该Thread对象才是真正的线程对象。
调用线程对象的start()方法来启动线程。
代码如下：
测试类：

public class TestRunnable {
    public static void main(String[] args) {
        //创建RunnableTarget对象
        RunnableTarget runnableTarget = new RunnableTarget();
        //把RunnableTarget对象和thread的名字作为Thread构造函数的参数传入，让thread能执行RunnableTarget的run方法中的内容
        Thread thread = new Thread(runnableTarget,"runnableThread");
        //开启线程
        thread.start();
        //主线程的执行内容
        for (int i = 0; i < 5; i++) {
            System.out.println("main线程正在执行"+i);
        }
    }
}

自定义的Runnable接口实现类：

/**
 * 自己写一个Runnable接口实现类，作为Thread构造函数的参数targer传入，创建Thread对象，
 * 注意，这种方式最终执行的对象是thread,而执行的内容是Runnable实现类中重写的run方法内的内容。
 */
public class RunnableTarget implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println(Thread.currentThread().getName()+"执行到了"+i);
            
        }
    }
}

执行结果;
在这里插入图片描述
Runnable对象仅仅作为Thread对象的target，Runnable实现类里包含的run()方法仅作为线程执行体。而实际的线程对象依然是Thread实例，只是该Thread线程负责执行其target的run()方法。

在启动的多线程的时候，需要先通过Thread类的构造方法Thread(Runnable target) 构造出对象，然后调用Thread 对象的start()方法来运行多线程代码。
实际上所有的多线程代码都是通过运行Thread的start()方法来运行的。

因此，不管是继承Thread类还是实现 Runnable接口来实现多线程，最终还是通过Thread的对象的API来控制线程的，熟悉Thread类的API是进行多线程编程的基础。

继承Thread和实现Runnable两种方式的区别：

继承Thread实现的模式是定义多个线程,各自完成各自的任务.，而实现Runnable实现的模式是定义多个线程,实现一个任务.可理解为一个是多个线程分别完成自己的任务，一个是多个线程共同完成一个任务。
如果一个类继承Thread，则不适合资源共享。但是如果实现了Runable接口的话，则很容易的实现资源共享。继承Thread类的线程有着自己独立的资源空间，而实现Runnable接口的方式，所有线程都享有该Runable实现类的资源，比如在该类中放一笔钱，每个线程都能从中取钱放钱，并且效果是叠加的。
实现Runnable接口比继承Thread类所具有的优势：