JavaSE-多线程（1）- 线程概念_java 多线程 sql-优快云博客

本文链接：https://blog.youkuaiyun.com/sql2008help/article/details/120715782

本文详细介绍了Java中的进程和线程概念，通过实例展示了进程和线程的区别。同时，讲解了多线程的实现方式，包括继承Thread类、实现Runnable接口以及使用线程池，并探讨了线程常用方法如sleep()、yield()和join()的使用场景及效果。此外，还分析了线程的状态转换，并给出了线程同步的示例。

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

JavaSE-多线程（1）- 线程概念

进程：

进程是程序的一次执行过程，在java中启动main函数就是启动了一个JVM进程
例如，当执行下面两个类时，即启动了两个进程：

public class ProcessTest {

    public static void main(String[] args) {
        while(true){
            try {
                Thread.sleep(2000);
                System.out.println("Process1 running ...");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

public class ProcessTest2 {

    public static void main(String[] args) {
        while(true){
            try {
                Thread.sleep(2000);
                System.out.println("Process2 running ...");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

线程：

线程可以理解成是进程的更小执行单元，一个进程在执行过程中可以产生多个线程，与进程不同的是同类的多个线程共享进程的堆和方法区资源，但每个线程有自己的程序计数器、虚拟机栈和本地方法栈，所以系统在产生一个线程，或是在各个线程之间作切换工作时，负担要比进程小得多，也正因为如此，线程也被称为轻量级进程，在上例中一个进程只产生了一个线程即主线程，在以下例子中，共有三个线程在运行即 main ，Thread-0，Thread-1 。

public class ThreadTest extends Thread {

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            try {
                Thread.sleep(2000);
                System.out.println(Thread.currentThread().getName() + " running...");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) {
        new ThreadTest().start();
        new ThreadTest().start();
        for (int i = 0; i < 100; i++) {
            try {
                Thread.sleep(2000);
                System.out.println(Thread.currentThread().getName() + " running...");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

main running...
Thread-1 running...
Thread-0 running...
Thread-1 running...
main running...
Thread-0 running...
Thread-1 running...
main running...
........................

实现多线程的三种方式：

继承 Thread 类
实现 Runnable 接口
通过线程池 Executors.newCachedThreadPool 启动

线程常用方法

Thread.sleep(long millis) ：

一定是当前线程调用此方法，当前线程进入TIMED_WAITING状态，但不释放对象锁，millis后线程自动苏醒进入就绪状态。作用：给其它线程执行机会的最佳方式。

package com.hs.example.base.multithread.day01;

public class SleepTest implements Runnable {


    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println(Thread.currentThread().getState());
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) {
        Thread thread = new Thread(new SleepTest());
        thread.start();

        do {
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(thread.getState());
        } while (!Thread.State.TERMINATED.equals(thread.getState()));
    }
}

程序运行结果为：

RUNNABLE
TIMED_WAITING
RUNNABLE
RUNNABLE
TIMED_WAITING
........省略
TERMINATED

Thread.yield()：

yield 字面意思为让步，jdk文档解释为暂停当前正在执行的线程对象，并执行其他线程，调用该方法会释放CPU资源，但不会释放锁资源，当前线程从运行中状态进入就绪（RUNNABLE）状态，Thread.yield()不会导致阻塞。该方法与sleep()类似，只是不能由用户指定暂停多长时间

join ：

等待该线程终止，一般使用方法为在当前线程A调用线程B的join方法，此时A线程会等待B线程执行完才会继续执行。

public class JoinTest implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + " " + i);
        }
    }

    public static void main(String[] args) {
        System.out.println(Thread.currentThread().getName() + " start...");
        Thread thread = new Thread(new JoinTest());
        thread.start();
        try {
            thread.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + " end...");
    }
}

此例中执行结果为：

main start...
Thread-0 0
Thread-0 1
Thread-0 2
Thread-0 3
Thread-0 4
Thread-0 5
Thread-0 6
Thread-0 7
Thread-0 8
Thread-0 9
main end...

但是如果注释 thread.join(); 执行结果为：

main start...
main end...
Thread-0 0
Thread-0 1
Thread-0 2
Thread-0 3
Thread-0 4
Thread-0 5
Thread-0 6
Thread-0 7
Thread-0 8
Thread-0 9

线程状态：

下例中，一个线程运行时，另外一个线程属于阻塞状态

public class BlockedThreadTest implements Runnable {

    private final Object o = new Object();

    @Override
    public void run() {
        synchronized (o) {
            System.out.println("run begin，" + Thread.currentThread().getName() + "  " + Thread.currentThread().getState());
            try {
                Thread.sleep(5000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("run end，" + Thread.currentThread().getName() + "  " + Thread.currentThread().getState());
        }
    }

    public static void main(String[] args) {
        Runnable runnable = new BlockedThreadTest();
        Thread t1 = new Thread(runnable);
        t1.setName("t1");
        t1.start();
        Thread t2 = new Thread(runnable);
        t2.setName("t2");
        t2.start();
        do {
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(t1.getName() + ":" + t1.getState() + "  " + t2.getName() + ":" + t2.getState());
        } while (!Thread.State.TERMINATED.equals(t1.getState()) || !Thread.State.TERMINATED.equals(t2.getState()));
    }
}

run begin，t1  RUNNABLE
t1:TIMED_WAITING  t2:BLOCKED
t1:TIMED_WAITING  t2:BLOCKED
t1:TIMED_WAITING  t2:BLOCKED
t1:TIMED_WAITING  t2:BLOCKED
t1:TIMED_WAITING  t2:BLOCKED
t1:TIMED_WAITING  t2:BLOCKED
t1:TIMED_WAITING  t2:BLOCKED
t1:TIMED_WAITING  t2:BLOCKED
t1:TIMED_WAITING  t2:BLOCKED
run end，t1  RUNNABLE
run begin，t2  RUNNABLE
t1:TERMINATED  t2:TIMED_WAITING
t1:TERMINATED  t2:TIMED_WAITING
t1:TERMINATED  t2:TIMED_WAITING
t1:TERMINATED  t2:TIMED_WAITING
t1:TERMINATED  t2:TIMED_WAITING
t1:TERMINATED  t2:TIMED_WAITING
t1:TERMINATED  t2:TIMED_WAITING
t1:TERMINATED  t2:TIMED_WAITING
t1:TERMINATED  t2:TIMED_WAITING
t1:TERMINATED  t2:TIMED_WAITING
run end，t2  RUNNABLE
t1:TERMINATED  t2:TERMINATED

参考：
https://www.zhihu.com/question/264627396
https://blog.youkuaiyun.com/shinecjj/article/details/82995309