前言

Java多线程是一种并发编程方式，允许Java应用程序同时执行多个独立任务。它通过创建和管理多个线程来实现，

每个线程代表一个独立的执行流。多线程可以提高程序性能、资源利用率和响应能力。Java提供了Thread类和Runnable接口来创建和操作线程，

还包括同步机制（synchronization）来确保线程安全。多线程适用于处理并行计算、异步操作、GUI编程等场景。然而，多线程编程也需要小心处理竞态条件、死锁等问题，以确保程序正确运行。

🌊 关注我不迷路，如果本篇文章对你有所帮助，或者你有什么疑问，欢迎在评论区留言，我一般看到都会回复的。大家点赞支持一下哟~ 💗

并发、并行、进程、线程概念

并发与并行

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

在操作系统中，安装了多个程序，并行指的是在一段时间内宏观上有多个程序同时运行，这在单 CPU 系统中，每一时刻只能有一道程序执行，即

微观上这些程序是分时的交替运行，只不过是给人的感觉是同时运行，那是因为分时交替运行的时间是非常短的。

而在多个 CPU 系统中，则这些可以并发执行的程序便可以分配到多个处理器上（CPU），实现多任务并行

执行，即利用每个处理器来处理一个可以并发执行的程序，这样多个程序便可以同时执行。目前电脑市场上说的多核 CPU，便是多核处理器，核

越多，并行处理的程序越多，能大大的提高电脑运行的效率。

线程与进程

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

进程

打开活动监视器

线程

线程调度:

● 分时调度

所有线程轮流使用 CPU 的使用权，平均分配每个线程占用 CPU 的时间。

● 抢占式调度

优先让优先级高的线程使用 CPU，如果线程的优先级相同，那么会随机选择一个(线程随机性)，Java使用的为抢占式调度。

大部分操作系统都支持多进程并行运行，现在的操作系统几乎都支持同时运行多个程序。比如：现在我们上课一边使用编辑器，一边使用录屏软件，同时还开着画图板，dos窗口等软件。此时，这些程序是在同时运行，”感觉这些软件好像在同一时刻运行着“。

实际上，CPU(中央处理器)使用抢占式调度模式在多个线程间进行着高速的切换。对于CPU的一个核而言，某个时刻，只能执行一个线程，而

CPU的在多个线程间切换速度相对我们的感觉要快，看上去就是在同一时刻运行。

其实，多线程程序并不能提高程序的运行速度，但能够提高程序运行效率，让CPU的使用率更高。

创建线程

继承Thread类

定义Thread类的子类，并重写该类的run()方法，该run()方法的方法体就代表了线程需要完成的任务,因此把run()方法称为线程执行体。
创建Thread子类的实例，即创建了线程对象
调用线程对象的start()方法来启动该线程

示例:

public class MyThread extends Thread {
    //定义指定线程名称的构造方法
    public MyThread(String name) {
        //调用父类的String参数的构造方法，指定线程的名称
        super(name);
    }
    /**
     * 重写run方法，完成该线程执行的逻辑
     */
    @Override
    public void run() {
        for (int i = 0; i < 200; i++) {
            System.out.println(getName() + "：" + i);
        }
    }
}

测试

public class Demo1 {
    public static void main(String[] args) {
        //创建自定义线程对象
        MyThread mt = new MyThread("新建的线程");
        //开启新线程
        mt.start();
        //在主方法中执行for循环
        for (int i = 0; i < 10; i++) {
            System.out.println("主线程：" + i);
        }
    }
}

实现Runnable接口

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

public class MyRunnable implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i < 200; i++) {
            System.out.println(Thread.currentThread().getName() + " " + i);
        }
    }
}

测试

public class Demo2 {
    public static void main(String[] args) {         //创建自定义类对象  线程任务对象
        MyRunnable mr = new MyRunnable();
        //创建线程对象
        Thread t = new Thread(mr, "新建的线程");
        t.start();
        for (int i = 0; i < 20; i++) {
            System.out.println("主线程" + i);
        }
    }
}

继承Thread 和实现Runnable的区别

如果一个类继承Thread，则不适合资源共享。但是如果实现了Runable接口的话，则很容易的实现资源共享。总结：

*实现Runnable接口比继承Thread类所具有的优势**：

适合多个相同的程序代码的线程去共享同一个资源。
可以避免java中的单继承的局限性。
增加程序的健壮性，实现解耦操作，代码可以被多个线程共享，代码和线程独立。

线程常用方法

方法名	说明
public static void sleep(long millis)	当前线程主动休眠 millis 毫秒。
public static void yield()	当前线程主动放弃时间片，回到就绪状态，竞争下一次时间片。
public final void join()	允许其他线程加入到当前线程中。
public void setPriority(int)	线程优先级为1-10，默认为5,优先级越高，表示获取CPU机会越多。
public void setDaemon(boolean)	设置为守护线程线程有两类：用户线程（前台线程）、守护线程（后台线程）

线程的优先级

我们可以通过传递参数给线程的 setPriority() 来设置线程的优先级别
调整线程优先级：Java线程有优先级，优先级高的线程会获得较多的运行机会。优先级 : 只能反映线程的中或者是紧急程度 , 不能决定是否一定先执行Java线程的优先级用整数表示，取值范围是1~10，Thread类有以下三个静态常量：

static int MAX_PRIORITY 线程可以具有的最高优先级，取值为10。 static int MIN_PRIORITY 线程可以具有的最低优先级，取值为1。 static int NORM_PRIORITY 分配给线程的默认优先级，取值为5。

示例:

/**
 * 优先级
 *
 */
public class PriorityThread extends Thread {
    @Override
    public void run() {
        for (int i = 0; i < 50; i++) {
            System.out.println(Thread.currentThread().getName() + "============" + i);
        }
    }
}

测试:

public class TestPriority {
    public static void main(String[] args) {
        PriorityThread p1 = new PriorityThread();
        p1.setName("p1");
        PriorityThread p2 = new PriorityThread();
        p2.setName("p2");
        PriorityThread p3 = new PriorityThread();
        p3.setName("p3");
        p1.setPriority(1);
        p3.setPriority(10);
        //启动
        p1.start();
        p2.start();
        p3.start();
    }
}

线程的休眠

使用线程的 sleep() 可以使线程休眠指定的毫秒数,在休眠结束的时候继续执行线程

示例：

class SleepThread extends Thread {
    @Override
    public void run() {
        String[] names = new String[]{"zs", "ls", "ww", "z6"};
        int index = (int) (Math.random() * 4);
        for (int i = 3; i > 0; i--) {
            System.out.println(i);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("倒计时：" + i);
        }
        System.out.println("抽中学员为:" + names[index]);
    }
}

测试:

public class TestSleep {
    public static void main(String[] args) {
        new SleepThread().start();
    }
}

线程的让步

Thread.yield() 方法作用是：暂停当前正在执行的线程对象（及放弃当前拥有的cup资源），并执行其他线程。
yield() 做的是让当前运行线程回到可运行状态，以允许具有相同优先级的其他线程获得运行机会。因此，使用 yield()的目的是让相同优先级的线程之间能适当的轮转执行。但是，实际中无法保证**yield()**达到让步目的，因为让步的线程还有可能被线程调度程序再次选中。
案例:创建两个线程A,B,分别各打印1000次,从1开始每次增加1,其中B一个线程,每打印一次,就yield一次,观察实验结果.

示例：

class Task1 implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i < 200; i++) {
            System.out.println("A:" + i);
        }
    }
}
class Task2 implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println("B:" + i);
            Thread.yield();
        }
    }
}
public class Demo {
    public static void main(String[] args) {
        new Thread(new Task2()).start();
        new Thread(new Task1()).start();
    }
}

sleep()和yield()的区别

sleep()使当前线程进入停滞状态，所以执行sleep()的线程在指定的时间内肯定不会被执行；

yield()只是使当前线程重新回到可执行状态，所以执行yield()的线程有可能在进入到可执行状态后马上又被执行。

sleep 方法使当前运行中的线程睡眼一段时间，进入不可运行状态，这段时间的长短是由程序设定的，yield 方法使当前线程让出 CPU

占有权，但让出的时间是不可设定的。实际上，yield()方法对应了如下操作：先检测当前是否有相同优先级的线程处于同可运行状态，如有，则把

CPU 的占有权交给此线程，否则，继续运行原来的线程。所以yield()方法称为“退让”，它把运行机会让给了同等优先级的其他线程

另外，sleep 方法允许较低优先级的线程获得运行机会，但 yield() 方法执行时，当前线程仍处在可运行状态，所以，不可能让出较低优先级的线程些时获得

CPU 占有权。在一个运行系统中，如果较高优先级的线程没有调用 sleep 方法，又没有受到 I\O

阻塞，那么，较低优先级线程只能等待所有较高优先级的线程运行结束，才有机会运行。

线程的合并

Thread 中，join()方法的作用是调用线程等待该线程完成后，才能继续往下运行。
join是Thread类的一个方法，启动线程后直接调用，即join() 的作用是：“等待该线程终止”，这里需要理解的就是该线程是指的主线程等待子线程的终止。也就是在子线程调用了join() 方法后面的代码，只有等到子线程结束了才能执行。

为什么要用join()方法在很多情况下，主线程生成并起动了子线程，如果子线程里要进行大量的耗时的运算，主线程往往将于子线程之前结束，但是如果主线程处理完其他的事务后，需要用到子线程的处理结果，也就是主线程需要等待子线程执行完成之后再结束，这个时候就要用到join() 方法了。

示例：

class JoinThread extends Thread {
    public JoinThread(String name) {
        super(name);
    }
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + "线程开始运行");
        for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName() + "-->子线程：" + i);
        }
        System.out.println(Thread.currentThread().getName() + "线程结束运行");
    }
}
public class JoinDemo {
    public static void main(String[] args) {
        System.out.println("主线程开始运行。。。");
        // 新加入的子线程  
        JoinThread t1 = new JoinThread("新加入的线程");
        t1.start();
//        try {
//            t1.join();
//        } catch (InterruptedException e) {
//            e.printStackTrace();
//        }
        System.out.println("主线程开始结束。。。");
    }
}

最后

本期结束咱们下次再见👋~

🌊 关注我不迷路，如果本篇文章对你有所帮助，或者你有什么疑问，欢迎在评论区留言，我一般看到都会回复的。大家点赞支持一下哟~ 💗

深入理解Java并发编程：并行与并发、进程与线程、优先级、休眠与让步

前言