【MapSheep】
[好记性不如烂笔头]
posts - 228,comments - 15,views - 17万
Java 多线程
  1. 进程
    • 进程是程序的一次动态执行过程，它需要经历从代码加载，代码执行、执行完毕、最终消亡的过程。
  2. 线程
    • 线程是进程的基础之上进行进一步的划分。
  3. 多线程
    • 多线程是实现并发机制的一种有效手段。

Java中线程实现的方式

> 在 Java 中实现多线程有两种手段，一种是继承 Thread 类，另一种就是实现 Runnable 接口。下面我们就分别来介绍这两种方式的使用。
  1. 实现 Runnable 接口
package Thread;
 
public class MyThread implements Runnable { // 实现Runnable接口，作为线程的实现类 
 
    private String name;       // 表示线程的名称
 
    MyThread(String name) {
        this.name = name;      // 通过构造方法配置name属性
    }
 
    // TODO 覆写run()方法，作为线程 的操作主体
    @Override
    public void run() {
        for (int i = 0; i < 4; i++) {
            System.out.println(name + "运行，i = " + i);
        }
    }
 
    public static void main(String[] args) {
        MyThread mt1 = new MyThread("线程A");    // 实例化对象
        MyThread mt2 = new MyThread("线程B");    // 实例化对象
        Thread t1 = new Thread(mt1);       // 实例化Thread类对象
        Thread t2 = new Thread(mt2);       // 实例化Thread类对象
        t1.start();    // 启动多线程
        t2.start();    // 启动多线程
 
        // 线程A运行，i = 0
        // 线程A运行，i = 1
        // 线程A运行，i = 2
        // 线程B运行，i = 0
        // 线程B运行，i = 1
        // 线程B运行，i = 2
        // 线程B运行，i = 3
        // 线程A运行，i = 3
    }
}
  1. 继承 Thread 类
package Thread;
 
public class MyThread extends Thread {  // 继承Thread类，作为线程的实现类
    private String name;       // 表示线程的名称
 
    public MyThread(String name) {
        this.name = name;      // 通过构造方法配置name属性
    }
 
    public void run() {  // 覆写run()方法，作为线程 的操作主体
        for (int i = 0; i < 4; i++) {
            System.out.println(name + "运行，i = " + i);
        }
    }
 
    public static void main(String[] args) {
        MyThread mt1 = new MyThread("线程A ");    // 实例化对象
        MyThread mt2 = new MyThread("线程B ");    // 实例化对象
        mt1.start();   // 调用线程主体
        mt2.start();   // 调用线程主体
 
        // 线程A 运行，i = 0
        // 线程B 运行，i = 0
        // 线程A 运行，i = 1
        // 线程B 运行，i = 1
        // 线程A 运行，i = 2
        // 线程B 运行，i = 2
        // 线程A 运行，i = 3
        // 线程B 运行，i = 3
        
    }
}
  1. 取得和设置线程的名称
public class MyThread implements Runnable { //实现Runnable接口
 
    @Override
    public void run() {
        for (int i = 0; i < 4; i++) {
            System.out.println(Thread.currentThread().getName() + "运行,第" + i + "次！"); //取得当前线程的名称
        }
    }
 
    public static void main(String[] args) {
        MyThread myThread = new MyThread(); //定义Runnable子类对象
        new Thread(myThread).start(); //系统自动设置线程名称
        System.out.println("------------");
        new Thread(myThread, "线程A").start(); //手工设置线程名称
		
		/*Thread-0运行,第0次！
		Thread-0运行,第1次！
		Thread-0运行,第2次！
		Thread-0运行,第3次！
		线程A运行,第0次！
		线程A运行,第1次！
		线程A运行,第2次！
		线程A运行,第3次！*/
    }
}
  1. 运行结果
    • 从程序可以看出，现在的两个线程对象是交错运行的，哪个线程对象抢到了 CPU 资源，哪个线程就可以运行，所以程序每次的运行结果肯定是不一样的。
    • 在线程启动虽然调用的是 start() 方法，但实际上调用的却是 run() 方法定义的主体。

线程的状态变化

> 要想实现多线程，必须在主线程中创建新的线程对象。任何线程一般具有5种状态，即创建，就绪，运行，阻塞，终止。下面分别介绍一下这几种状态：
  1. 在此提出一个问题，Java 程序每次运行至少启动几个线程？
    • 回答：至少启动两个线程，每当使用 Java 命令执行一个类时，实际上都会启动一个 JVM，每一个JVM实际上就是在操作系统中启动一个线程。
    • Java 本身具备了垃圾的收集机制。
    • 所以在 Java 运行时至少会启动两个线程，一个是 main 线程，另外一个是垃圾收集线程
  2. 创建状态
    • 在程序中用构造方法创建了一个线程对象后，新的线程对象便处于新建状态，此时它已经有了相应的内存空间和其他资源，但还处于不可运行状态。
    • 新建一个线程对象可采用Thread 类的构造方法来实现，例如 “Thread thread=new Thread()”。
  3. 就绪状态
    • 新建线程对象后，调用该线程的 start() 方法就可以启动线程。
    • 当线程启动时，线程进入就绪状态。
    • 此时，线程将进入线程队列排队，等待 CPU 服务，这表明它已经具备了运行条件。
  4. 运行状态
    • 当就绪状态被调用并获得处理器资源时，线程就进入了运行状态。
    • 此时，自动调用该线程对象的 run() 方法。run() 方法定义该线程的操作和功能。
  5. 阻塞状态
    • 一个正在执行的线程在某些特殊情况下，如被人为挂起或需要执行耗时的输入/输出操作，会让 CPU 暂时中止自己的执行，进入阻塞状态。
    • 在可执行状态下，如果调用sleep(),suspend(),wait() 等方法，线程都将进入阻塞状态。
    • 发生阻塞时线程不能进入排队队列，只有当引起阻塞的原因被消除后，线程才可以转入就绪状态。
  6. 死亡状态
    • 线程调用 stop() 方法时或 run() 方法执行结束后，即处于死亡状态。
    • 处于死亡状态的线程不具有继续运行的能力。

线程的操作方法

> 刚才在分析自定义模式工作原理的时候其实就已经提到了，如果想要更改Glide的默认配
  1. 线程的强制运行
    • 在线程操作中，可以使用 join() 方法让一个线程强制运行，线程强制运行期间，其他线程无法运行，必须等待此线程完成之后才可以继续执行。
public class MyThread implements Runnable { //实现Runnable接口
 
    @Override
    public void run() { //覆写run()方法
        for (int i = 0; i < 4; i++) {
            System.out.println(Thread.currentThread().getName() + "运行,第" + i + "次！"); //取得当前线程的名称
        }
    }
 
    public static void main(String[] args) {
        MyThread myThread = new MyThread(); //定义Runnable子类对象
        new Thread(myThread).start(); //系统自动设置线程名称
        System.out.println("------------");
        Thread threadA = new Thread(myThread, "线程A");//手工设置线程名称
        threadA.start();
        for (int i = 0; i < 10; i++) {
            if (i > 5) {
                try {
                    threadA.join();  // 线程强制运行
                } catch (InterruptedException e) {
                    e.printStackTrace(); //打印堆栈跟踪
                }
            }
            System.out.println("Main线程运行 --> " + i);
        }
        /*Main线程运行 --> 0
        Main线程运行 --> 1
        Main线程运行 --> 2
        Main线程运行 --> 3
        Main线程运行 --> 4
        Main线程运行 --> 5
        Thread-0运行,第0次！
        Thread-0运行,第1次！
        Thread-0运行,第2次！
        Thread-0运行,第3次！
        线程A运行,第0次！
        线程A运行,第1次！
        线程A运行,第2次！
        线程A运行,第3次！
        Main线程运行 --> 6
        Main线程运行 --> 7
        Main线程运行 --> 8
        Main线程运行 --> 9*/
    }
}
  1. 取得和设置线程的名称
public class MyThread implements Runnable { //实现Runnable接口
 
    @Override
    public void run() {
        for (int i = 0; i < 4; i++) {
            System.out.println(Thread.currentThread().getName() + "运行,第" + i + "次！"); //取得当前线程的名称
        }
    }
 
    public static void main(String[] args) {
        MyThread myThread = new MyThread(); //定义Runnable子类对象
        new Thread(myThread).start(); //系统自动设置线程名称
        System.out.println("------------");
        new Thread(myThread, "线程A").start(); //手工设置线程名称
		
		/*Thread-0运行,第0次！
		Thread-0运行,第1次！
		Thread-0运行,第2次！
		Thread-0运行,第3次！
		线程A运行,第0次！
		线程A运行,第1次！
		线程A运行,第2次！
		线程A运行,第3次！*/
    }
}

线程的操作方法

> 刚才在分析自定义模式工作原理的时候其实就已经提到了，如果想要更改Glide的默认配
  1. 线程的强制运行
    • 在线程操作中，可以使用 join() 方法让一个线程强制运行，线程强制运行期间，其他线程无法运行，必须等待此线程完成之后才可以继续执行。
public class MyThread implements Runnable { //实现Runnable接口
 
    @Override
    public void run() { //覆写run()方法
        for (int i = 0; i < 4; i++) {
            System.out.println(Thread.currentThread().getName() + "运行,第" + i + "次！"); //取得当前线程的名称
        }
    }
 
    public static void main(String[] args) {
        MyThread myThread = new MyThread(); //定义Runnable子类对象
        new Thread(myThread).start(); //系统自动设置线程名称
        System.out.println("------------");
        Thread threadA = new Thread(myThread, "线程A");//手工设置线程名称
        threadA.start();
        for (int i = 0; i < 10; i++) {
            if (i > 5) {
                try {
                    threadA.join();  // 线程强制运行
                } catch (InterruptedException e) {
                    e.printStackTrace(); //打印堆栈跟踪
                }
            }
            System.out.println("Main线程运行 --> " + i);
        }
        /*Main线程运行 --> 0
        Main线程运行 --> 1
        Main线程运行 --> 2
        Main线程运行 --> 3
        Main线程运行 --> 4
        Main线程运行 --> 5
        Thread-0运行,第0次！
        Thread-0运行,第1次！
        Thread-0运行,第2次！
        Thread-0运行,第3次！
        线程A运行,第0次！
        线程A运行,第1次！
        线程A运行,第2次！
        线程A运行,第3次！
        Main线程运行 --> 6
        Main线程运行 --> 7
        Main线程运行 --> 8
        Main线程运行 --> 9*/
    }
}
  1. 线程的休眠
    • 在程序中允许一个线程进行暂时的休眠，直接使用 Thread.sleep() 即可实现休眠。
public class MyThread implements Runnable { //实现Runnable接口
 
    @Override
    public void run() {
        for (int i = 0; i < 4; i++) {
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "运行,第" + i + "次！"); //取得当前线程的名称
        }
    }
 
    public static void main(String[] args) {
        MyThread mt = new MyThread(); //实例化Runnable子类对象
        Thread t = new Thread(mt, "线程"); //实例化Thread对象
        t.start(); //启动线程
		
		/*线程运行,第0次！
        线程运行,第1次！
        线程运行,第2次！
        线程运行,第3次！
        TODO 每隔0.5秒输出一次
        */
    }
}
  1. 中断线程
    • 当一个线程运行时，另外一个线程可以直接通过interrupt()方法中断其运行状态。
public class MyThread implements Runnable { //实现Runnable接口
 
    @Override
    public void run() {
        System.out.println("1、进入run()方法");
        try {
            Thread.sleep(10000); //线程休眠10秒
            System.out.println("2、已经完成了休眠");
        } catch (InterruptedException e) {
            System.out.println("3、休眠被终止02");
            return; // 返回调用处
        }
        System.out.println("4、run()方法正常结束");
    }
 
    public static void main(String[] args) {
        MyThread mt = new MyThread(); //实例化Runnable子类对象
        Thread t = new Thread(mt, "线程"); //实例化Thread对象
        t.start(); //启动线程
        try {
            Thread.sleep(2000);    // 线程休眠2秒
        } catch (InterruptedException e) {
            System.out.println("3、休眠被终止01");
        }
        t.interrupt(); // 中断线程执行
		// 1、进入run()方法
		// 3、休眠被终止02
    }
}
  1. 后台线程
    • 在 Java 程序中, 只要前台有一个线程在运行, 则整个 Java 进程都不会消失, 所以此时可以设置一个后台线程, 这样即使 Java 线程结束了, 此后台线程依然会继续执行, 要想实现这样的操作, 直接使用 setDaemon() 方法即可。
    • 在线程类 MyThread 中，尽管 run() 方法中是死循环的方式，但是程序依然可以执行完，因为方法中死循环的线程操作已经设置成后台运行。
public class MyThread implements Runnable { //实现Runnable接口
 
    @Override
    public void run() {
        for (int i = 0; i < 4; i++) {
            System.out.println(Thread.currentThread().getName() + "运行,第" + i + "次！"); //取得当前线程的名称
        }
    }
 
    public static void main(String[] args) {
        MyThread mt = new MyThread(); //实例化Runnable子类对象
        Thread t = new Thread(mt, "线程"); //实例化Thread对象
        t.setDaemon(true); //设置线程在后台运行, 不会打印日志
        t.start(); //启动线程
    }
}
  1. 线程的优先级
    • 在 Java 的线程操作中, 所有的线程在运行前都会保持在就绪状态, 那么此时, 哪个线程的优先级高, 哪个线程就有可能会先被执行。
    • 从程序的运行结果中可以观察到, 线程将根据其优先级的大小来决定哪个线程会先运行, 但是需要注意并非优先级越高就一定会先执行, 哪个线程先执行将由 CPU 的调度决定。
public class MyThread implements Runnable { //实现Runnable接口
 
    @Override
    public void run() {
        for (int i = 0; i < 4; i++) {
            System.out.println(Thread.currentThread().getName() + "运行,第" + i + "次！"); //取得当前线程的名称
        }
    }
 
    public static void main(String[] args) {
        MyThread mt01 = new MyThread(); //实例化Runnable子类对象
        MyThread mt02 = new MyThread();
        MyThread mt03 = new MyThread();
        Thread t01 = new Thread(mt01, "线程A"); //实例化Thread对象
        Thread t02 = new Thread(mt02, "线程B"); //实例化Thread对象
        Thread t03 = new Thread(mt03, "线程C"); //实例化Thread对象
 
        //设置线程的优先级
        t01.setPriority(Thread.MAX_PRIORITY);   // 优先级最高
        t02.setPriority(Thread.NORM_PRIORITY);  // 优先级最中等
        t03.setPriority(Thread.MIN_PRIORITY);   // 优先级最低
 
        t01.start();
        t02.start();
        t03.start();
        /*线程A运行,第0次！
        线程A运行,第1次！
        线程A运行,第2次！
        线程A运行,第3次！
        线程B运行,第0次！
        线程B运行,第1次！
        线程B运行,第2次！
        线程B运行,第3次！
        线程C运行,第0次！
        线程C运行,第1次！
        线程C运行,第2次！
        线程C运行,第3次！*/
    }
}
  1. 线程的礼让
    • 在线程操作中，也可以使用 yield() 方法将一个线程的操作暂时让给其他线程执行
public class MyThread implements Runnable { //实现Runnable接口
 
    @Override
    public void run() {
        for (int i = 0; i < 4; i++) {
            try {
                Thread.sleep(500);
            } catch (Exception e) {
            }
            System.out.println(Thread.currentThread().getName() + "运行,第" + i + "次！"); //取得当前线程的名称
            if (i == 2) {
                System.out.print("线程礼让: ");
                Thread.currentThread().yield();    //线程礼让
            }
        }
    }
 
    public static void main(String args[]) {
        MyThread my = new MyThread();  // 实例化MyThread对象
        Thread t1 = new Thread(my, "线程A");
        Thread t2 = new Thread(my, "线程B");
        t1.start();
        t2.start();
        /*线程B运行,第0次！
        线程A运行,第0次！
        线程B运行,第1次！
        线程A运行,第1次！
        线程A运行,第2次！
        线程B运行,第2次！
        线程礼让: 线程礼让: 线程A运行,第3次！
        线程B运行,第3次！*/
    }
}

同步以及死锁

  1. 一个多线程的程序如果是通过 Runnable 接口实现的，则意味着类中的属性被多个线程共享，那么这样就会造成一种问题，如果这多个线程要操作同一个资源时就有可能出现资源同步问题。
    • 解决方法：
    • 同步代码块
synchronized(同步对象){ 
	需要同步的代码 
}
 
class MyThread implements Runnable{
    private int ticket = 5 ;    // 假设一共有5张票
    public void run(){
        for(int i=0;i<100;i++){
            synchronized(this){ // 要对当前对象进行同步
                if(ticket>0){   // 还有票
                    try{
                        Thread.sleep(300) ; // 加入延迟
                    }catch(InterruptedException e){
                        e.printStackTrace() ;
                    }
                    System.out.println("卖票：ticket = " + ticket-- );
                }
            }
        }
    }
};
public class SyncDemo02{
    public static void main(String args[]){
        MyThread mt = new MyThread() ;  // 定义线程对象
        Thread t1 = new Thread(mt) ;    // 定义Thread对象
        Thread t2 = new Thread(mt) ;    // 定义Thread对象
        Thread t3 = new Thread(mt) ;    // 定义Thread对象
        t1.start() ;
        t2.start() ;
        t3.start() ;
 
		/*卖票：ticket = 5
        卖票：ticket = 4
        卖票：ticket = 3
        卖票：ticket = 2
        卖票：ticket = 1*/
    }
};
  1. 同步方法
    • 除了可以将需要的代码设置成同步代码块外，也可以使用 synchronized 关键字将一个方法声明为同步方法。
    • 从程序运行的结果可以发现，此代码完成了与之前同步代码同样的功能。
synchronized 方法返回值 方法名称（参数列表）{}
 
class MyThread03 implements Runnable {
    private int ticket = 5;    // 假设一共有5张票
 
    public void run() {
        for (int i = 0; i < 100; i++) {
            this.sale();   // 调用同步方法
        }
    }
 
    public synchronized void sale() {    // 声明同步方法
        if (ticket > 0) {   // 还有票
            try {
                Thread.sleep(300); // 加入延迟
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("卖票：ticket = " + ticket--);
        }
 
    }
};
 
public class SyncDemo03 {
    public static void main(String args[]) {
        MyThread03 mt = new MyThread03();  // 定义线程对象
        Thread t1 = new Thread(mt);    // 定义Thread对象
        Thread t2 = new Thread(mt);    // 定义Thread对象
        Thread t3 = new Thread(mt);    // 定义Thread对象
        t1.start();
        t2.start();
        t3.start();
 
		/*卖票：ticket = 5
        卖票：ticket = 4
        卖票：ticket = 3
        卖票：ticket = 2
        卖票：ticket = 1*/
    }
};
  1. 死锁
    • 同步可以保证资源共享操作的正确性，但是过多同步也会产生问题。例如，现在张三想要李四的画，李四想要张三的书，张三对李四说“把你的画给我，我就给你书”，李四也对张三说“把你的书给我，我就给你画”两个人互相等对方先行动，就这么干等没有结果，这实际上就是死锁的概念。
    • 所谓死锁，就是两个线程都在等待对方先完成，造成程序的停滞，一般程序的死锁都是在程序运行时出现的。
    • 下面以一个简单范例说明这个概念, 以下代码不再执行，程序进入死锁状态。
class Zhangsan { // 定义张三类
    public void say() {
        System.out.println("张三对李四说：“你给我画，我就把书给你。”");
    }
 
    public void get() {
        System.out.println("张三得到画了。");
    }
};
 
class Lisi { // 定义李四类
    public void say() {
        System.out.println("李四对张三说：“你给我书，我就把画给你”");
    }
 
    public void get() {
        System.out.println("李四得到书了。");
    }
};
 
public class ThreadDeadLock implements Runnable {
    private static Zhangsan zs = new Zhangsan();       // 实例化static型对象
    private static Lisi ls = new Lisi();       // 实例化static型对象
    private boolean flag = false;  // 声明标志位，判断那个先说话
 
    public void run() {  // 覆写run()方法
        if (flag) {
            synchronized (zs) {   // 同步张三
                zs.say();
                try {
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized (ls) {
                    zs.get();
                }
            }
        } else {
            synchronized (ls) {
                ls.say();
                try {
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized (zs) {
                    ls.get();
                }
            }
        }
    }
 
    public static void main(String args[]) {
        ThreadDeadLock t1 = new ThreadDeadLock();      // 控制张三
        ThreadDeadLock t2 = new ThreadDeadLock();      // 控制李四
        t1.flag = true;
        t2.flag = false;
        Thread thA = new Thread(t1);
        Thread thB = new Thread(t2);
        thA.start();
        thB.start();
        //张三对李四说：“你给我画，我就把书给你。”
        //李四对张三说：“你给我书，我就把画给你”
    }
};

线程的启动方式

public class Test {
    public static void main(String[] args) {
        //线程启动01
        Thread magotan = new Thread(new Runnable() {
 
            @Override
            public void run() {
                System.out.println("MAGOTAN");
            }
        });
        
        //线程启动02
        Thread passat = new Thread(() -> System.out.println("PASSAT"));
 
        //一汽
        magotan.run();
        //上汽
        passat.run();
    }
	//TODO: MAGOTAN PASSAT
}
posted on   (Play)  阅读(62)  评论(0)  编辑  收藏  举报
编辑推荐：
· 从 HTTP 原因短语缺失研究 HTTP/2 和 HTTP/3 的设计差异
· AI与.NET技术实操系列：向量存储与相似性搜索在 .NET 中的实现
· 基于Microsoft.Extensions.AI核心库实现RAG应用
· Linux系列：如何用heaptrack跟踪.NET程序的非托管内存泄露
· 开发者必知的日志记录最佳实践
阅读排行：
· TypeScript + Deepseek 打造卜卦网站：技术与玄学的结合
· Manus的开源复刻OpenManus初探
· AI 智能体引爆开源社区「GitHub 热点速览」
· 从HTTP原因短语缺失研究HTTP/2和HTTP/3的设计差异
· 三行代码完成国际化适配，妙~啊~

Copyright © 2025 (Play)
Powered by .NET 9.0 on Kubernetes Powered By博客园
点击右上角即可分享
微信分享提示
SQL AI 助手