学习笔记：Java 多线程编程核心技术（第一章）

最新推荐文章于 2024-03-17 10:36:03 发布

stackfing

最新推荐文章于 2024-03-17 10:36:03 发布

阅读量232

点赞数 1

CC 4.0 BY-SA版权

分类专栏：笔记

本文链接：https://blog.youkuaiyun.com/stackfing/article/details/78086956

笔记专栏收录该内容

3 篇文章

订阅专栏

本文介绍了Java中多线程的实现方法，包括继承Thread类和实现Runnable接口，并探讨了线程安全问题及解决方案。此外还讲解了线程的常用方法、优先级、守护线程等概念。

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

Chapter 1 多线程技能

使用多线程

使用多线程有两种方式：

继承 Thread 类重写 run() 方法
实现 Runnable 接口

首先来看第一种方法

package com.syn.thread;

public class MyThread extends Thread{

    @Override
    public void run() {
        super.run();
        System.out.println("MyThread");
    }

    public static void main(String []args) {
        MyThread t = new MyThread();
        t.start();
    }
}

其实，通过查看 Thread 类的源码可以知道这个类也是实现了 Runnable 接口，也就是说我们无论用哪种方法，都是直接或者间接的实现了 Runnable 接口

我们知道 Java 中只支持单继承的，如果某个程序需要继承某个类，并且需要使用线程，那么第一种方法就没有办法实现了

但是好在我们可以使用第二种方法来实现 Runnable 接口

package com.syn.thread;

public class MyThread implements Runnable {

    @Override
    public void run() {
        System.out.println("MyThread");
    }

    public static void main(String []args) {
        MyThread t = new MyThread();
        Thread th = new Thread(t);
        th.start();
    }
}

在上面的例子中都是使用 xx.start() 方法来启动线程，而不是直接调用 xx.run()

Thread.java 类中的 start() 方法会通知 线程规划器，并告知此线程已经准备就绪，等待调用对象的 run() 方法，也就是让系统安排一个时间来调用 Thread 中的 run() 方法，此时是异步运行，main 方法中的代码可以一起运行。如果是直接调用 xx.run() 方法，那么就不是异步执行，而是同步执行。同步执行只有在运行完 run() 方法之后才能执行后面的代码，并且不会交给 线程规划器 来处理的

实例变量与线程安全

实例变量与线程安全有两种情况，第一是 不共享数据 第二种是共享数据

不共享数据就是变量不共享，也就不存在多个线程访问同一个实例变量的情况

共享数据的情况就相对麻烦了，因为会有多个线程访问同一个实例变量导致数据不正确

package com.syn.thread;

public class MyThread extends Thread {
    private int count = 5;

    @Override
    public void run() {
        super.run();
        count--;
        System.out.println("由 " + this.currentThread().getName() + " 计算 count " + count);
    }

    public static void main(String []args) {
        MyThread t1 = new MyThread();
        Thread a = new Thread(t1,"A");
        Thread b = new Thread(t1,"B");
        Thread c = new Thread(t1,"C");
        Thread d = new Thread(t1,"D");
        Thread e = new Thread(t1,"E");
        a.start();
        b.start();
        c.start();
        d.start();
        e.start();
    }
}

得出的结果是

由 A 计算 count 4

由 B 计算 count 2

由 C 计算 count 2

由 D 计算 count 1

由 E 计算 count 0

这样我们发现，B 和 C 打印出来的 count 值都是 2，说明了 B 和 C 线程是同时对 count 进行处理，这就产生了非线程安全的问题

解决非线程安全的问题是使用 synchronized 关键字，代码更改如下：

package com.syn.thread;

public class MyThread extends Thread {
    private int count = 5;

    @Override
    synchronized public void run() {
        super.run();
        count--;
        System.out.println("由 " + this.currentThread().getName() + " 计算 count " + count);
    }

    public static void main(String []args) {
        MyThread t1 = new MyThread();
        Thread a = new Thread(t1,"A");
        Thread b = new Thread(t1,"B");
        Thread c = new Thread(t1,"C");
        Thread d = new Thread(t1,"D");
        Thread e = new Thread(t1,"E");
        a.start();
        b.start();
        c.start();
        d.start();
        e.start();
    }
}