Java多线程学习 【万字详尽整理】

本人在学习了Java多线程知识后对相关知识点的整理,希望可以帮到需要的人,文中如有问题也请大家斧正。

  • Java多线程
    • 基础概念
        • 程序:
        • 进程:
        • 线程:
    • 线程的创建和使用 4种
        • 方式一:继承Thread类
        • 方式二:实现Runnable接口
        • 方式三:实现Callable接口
        • 方式四:使用线程池
    • 线程的生命周期
    • 线程的同步 3种
        • 方式一:同步代码块
        • 方式二:同步方法
        • 方式三:Lock(锁)
    • 线程的通信
    • 相关学习资料的推荐
        • 1.基础知识视频
        • 2.相关书籍

Java多线程

基础概念

程序:

​ 是为了完成特定任务、用某种语言编写的一组指令的集合。即指一段静态的代码。

进程:

​ 是程序的一次执行过程,或是正在运行的一个程序。是一个动态的过程:有它自身的产生、存在和消亡的过程,即生命周期。
进程是资源分配的最小单位

线程:

​ 线程被包含在进程中,一条线程指的是进程中一个单一顺序的控制流。

线程是调度和执行的最小单位,每个线程拥有独立的运行栈和程序计数器(pc)。

​ 一个进程中的多个线程共享相同的内存地址空间——它们从同一堆中分配对象,可以访问相同的变量和对象。这就使得线程间通信更加简便、高效。但多个线程操作共享系统资源可能就会带来安全隐患。

Java多线程学习 【万字详尽整理】_第1张图片

并发:多个CPU同时执行多个任务。
并行:一个CPU(采用时间片)同时执行多个任务。

线程的创建和使用 4种

方式一:继承Thread类

​ 1、创建一个继承于Thread类的子类。
​ 2、重写run()方法。
​ 3、创建实例。
​ 4、调用start()方法启动线程。

class MyThread extends Thread{
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println(i);
        }
    }
}
public class ThreadTest {
    public static void main(String[] args) {
        MyThread t1 = new MyThread();
        t1.start();
    }
}

start()方法的作用:
1、启动当前线程。2、调用当前线程的run()方法。

直接调用run()方法是无法启动线程,只是等同于调用普通类的实例的方法,还是在main线程中。
每个线程的start()方法只能调用一次,因为start()方法中维护了一个线程状态量,当不为零时抛出异常。

Thread类的有关方法:

run():线程在调度时执行的操作。
start():启动线程,调用run()。
String getName():返回线程的名称。
void setName(String name):设置该线程名字。
static Thread currentThread():返回当前线程。在Thread子类中就是this,通常用于主线程和Runnable实现类。
static void yield():线程让步。
暂停当前正在执行的线程,把执行机会让给优先级相同或更高的线程。
若队列中没有同优先级的线程,忽略此方法。
join():当某个程序执行流中调用其他线程的join()方法时,调用线程将被堵塞,直到join()方法加入的线程执行完为之。
低优先级的线程也可以获得执行。
static void sleep(long millis):(指定时间:毫秒)
令当前活动线程在指定时间段内放弃对CPU控制,使其他线程有机会被执行,时间到后重新排队。
stop():强制结束线程生命期。不推荐使用
boolean isAlive():判断线程是否还活着。

Java的调度方法:

同优先级线程组成先进先出队列(先到先服务),使用时间片策略。
对高优先级,使用优先调度的抢占策略。

线程的优先级:

线程的优先级等级:
MAX_PRIORITY:10
MIN_PRIORITY:1
NORM_PRIORITY:5

涉及的方法:
getPriority():返回线程优先值
setPriority(int newPriority):改变线程的优先级

说明:
线程创建时继承父线程的优先级。
低优先级只是获得调度的概率低,并非一定是高优先级线程调用之后才被调用。

方式二:实现Runnable接口

​ 1、创建一个实现了Runnable接口的类
​ 2、实现Runnable中的抽象方法:run()
​ 3、创建实现类的实例
​ 4、将此实例作为参数传递到Thread类中的构造器中,创建Thread类的对象
​ 5、通过Thread类的对象调用start()

class MyRun implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println(i);
        }
    }
}
public class ThreadTest1 {
    public static void main(String[] args) {
        MyRun r1 = new MyRun();
        Thread t1 = new Thread(r1);
        t1.start();
    }
}

实现Runnable方式中,start()方法的作用:
1、启动线程,Thread是线程,此例中是t1。
2、调用当前线程的run()方法,此时可能会有疑问,不是调用线程的run()嘛,怎么此例中调用的是实现Runnable接口的类的run()方法。这是因为,Thread类中声明了一个Runnable类型的属性target,当调用run()方法时,若target != null则调用target的run()方法。

方式一和方式二的比较:

开发中优先选择实现Runnable接口的方式:
1、实现的方式没有类的单继承性的限制。
2、实现的方式更适合来处理多个线程有共享数据的情况。

相同:
Thread类同样实现了Runnable接口。
都需要重写run()方法,将线程要执行的逻辑声明在run()方法中。

线程的分类:
Java中的线程分为两类:一种是守护线程,一种是用户线程。
它们在几乎每个方面都是相同的,唯一的区别是判断JVM何时离开。
守护线程是用来服务用户线程的,通过在start()方法前调用thread.setDaemon(true)可以把一个用户线程变成一个守护线程。
Java垃圾回收就是一个典型的守护线程。
若JVM中都是守护线程,当前JVM将退出。

方式三:实现Callable接口

与使用Runnable相比,Callable功能更强大些

  • 相比run()方法,可以有返回值
  • 方法可以抛出异常
  • 支持泛型的返回值
  • 需要借助FutureTask类,比如获取返回结果。
  • Future接口
    ➢可以对具体Runnable、Callable任务 的执行结果进行取消、查询是
    否完成、获取结果等。
    ➢Futrue Task是Futrue接口的唯一的实现类
    ➢FutureTask同时实现了Runnable, Future接口。它既可以作为
    Runnable被线程执行,又可以作为Future得到Callable的返回值

过程:

  1. 创建一个实现了Callable的实现类。
  2. 实现call方法,将此线程需要执行的操作声明在call()中。
  3. 创建实现类的对象
  4. 将此对象作为参数传递到FutureTask构造器中,创建FutureTask的对象
  5. 将FutureTask的对象作为参数传递到Thread类的构造器中,创建Thread对象,并调用start()。
lass Num implements Callable {
    private int sum = 0;
    @Override
    public Object call() throws Exception {
        for (int i = 0; i <= 100; i++) {
            if(i % 2 == 0){
                System.out.println(i);
                sum += i;
            }
        }
        return sum;
    }
}
public class NewThread {
    public static void main(String[] args) {
        Num n1 = new Num();
        FutureTask f1 = new FutureTask(n1);
        Thread t1 = new Thread(f1);
        t1.start();
        try {
            Object sum = f1.get();
            System.out.println("总和是:"+sum);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}

方式四:使用线程池

背景:经常创建和销毁、使用量特别大的资源,比如并发情况下的线程,对性能影响很大。
思路:提前创建好多个线程,放入线程池中,使用时直接获取,使用完放回池中。可以避免频繁创建销毁、实现重复利用。类似生活中的公共交通工具。
好处:
➢提高响应速度(减少了创建新线程的时间)
➢降低资源消耗(重复利用线程池中线程,不需要每次都创建)
➢便于线程管理.
corePoolSize:核心池的大小
maximumPoolSize: 最大线程数
keepAliveTime:线程没有任务时最多保持多长时间后会终止

JDK 5.0起提供了线程池相关API: ExecutorService 和Executors
ExecutorService:真正的线程池接口。常见子类ThreadPoolExecutor
➢void execute(Runnable command):执行任务/命令,没有返回值,一般用来执行Runnable
➢ Future submit(Callable task): 执行任务,有返回值,一般又来执行Callable
➢void shutdown() :关闭连接池
Executors:工具类、线程池的工厂类,用于创建并返回不同类型的线程池
➢Executors.newCachedThreadPool(): 创建一个可根据需要创建新线程的线程池
➢Executors .newFixedThreadPool(n);创建一个可 重用固定线程数的线程池
➢Executors.newSingle ThreadExecutor():创建一个只有 一个线程的线程池
➢Executors newScheduledThreadPool(n):创建一个线程池,它可安排在给定延迟后运行命令或者定期地执行。

class Num1 implements Runnable{

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            if(i % 2 == 0){
                System.out.println(Thread.currentThread().getName()+":"+i);
            }
        }
    }
}
class Num2 implements Runnable{

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            if(i % 2 != 0){
                System.out.println(Thread.currentThread().getName()+":"+i);
            }
        }
    }
}
public class ThreadPool {
    public static void main(String[] args) {
        ExecutorService service = Executors.newFixedThreadPool(10);
        service.execute(new Num1());
        service.execute(new Num2());

        service.shutdown();
    }
}

线程的生命周期

JDK中用Thread.State类(内部类)定义了线程的几种状态。

  • 新建:当一个Thread类或其子类的对象被声明并创建时,新生的线程对象处于新建状态。
  • 就绪:处于新建状态的线程被start()后,将进入线程队列等待CPU时间片,此时它已具备了运行的条件,只是没分配到CPU资源。
  • 运行:当就绪的线程被调度并获得CPU资源时,便进入运行状态,run()方法定义了线程的操作和功能。
  • 阻塞:在某种特殊情况下,被人为挂起或执行输入输出操作时,让出CPU并临时中止自己的执行,进入阻塞状态。
  • 死亡:线程完成了它的全部工作或线程被提前强制性地终止或出现异常导致结束。

Java多线程学习 【万字详尽整理】_第2张图片

线程的同步 3种

线程的同步机制是为了解决多线程中的线程安全问题。典型地例子有窗口售票,如下图

Java多线程学习 【万字详尽整理】_第3张图片

因为在操作未结束时,其他线程参与进来,所以车票出现了0和-1的错误车票。

方式一:同步代码块

synchronized(同步监视器){
    //需要被同步的代码
}
  1. 操作共享数据的代码,即为需要被同步的代码
  2. 共享数据:多个线程共同操作的变量。
  3. 同步监视器,俗称:锁。任何一个类的对象都可以充当锁。
  4. 多个线程必须要共用同一把锁。(实现Runnable接口创建多线程的方式中,可以考虑用this充当锁;继承Thread类创建多线程的方式中,可以考虑用当前类(----.class)来充当锁)。
class MyRun1 implements Runnable{

    private int ticket = 100;
    Object obj = new Object();
    @Override
    public void run() {
        while(true) {
            synchronized (obj) {
                if (ticket > 0) {
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + " :" + ticket);
                    ticket--;
                } else {
                    break;
                }
            }
        }
    }
}

public class TicketTest {
    public static void main(String[] args) {
        MyRun1 r1 = new MyRun1();

        Thread t1 = new Thread(r1);
        Thread t2 = new Thread(r1);
        Thread t3 = new Thread(r1);

        t1.setName("线程一");
        t2.setName("线程二");
        t3.setName("线程三");

        t1.start();
        t2.start();
        t3.start();

    }
}

方式二:同步方法

如果操作共享数据的代码完整的声明在一个方法中,我们不妨将此方法声明为同步的。

class MyRun1 implements Runnable{

    private int ticket = 100;
    Object obj = new Object();
    @Override
    public void run() {
        while(true) {
            if(ticket == 0)break;
            show();
        }
    }
    public synchronized void show(){
        if (ticket > 0) {
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + " :" + ticket);
            ticket--;
        }
    }
}

关于同步方法的总结:

  1. 同步方法仍然涉及到同步监视器,只是不需要我们显式的声明。
  2. 非静态的同步方法,同步监视器是:this。
  3. 静态的同步方法,同步监视器是:当前类本身。

死锁问题:

死锁:
不同的线程分别占用对方需要的同步资源不放弃,都在等待对方放弃自己需要的同步资源,就形成了线程的死锁。
出现死锁后,不会出现异常,不会出现提示,只是所有的线程都处于阻塞状态,无法继续。

解决方法:

​ 专门的算法、原则
​ 尽量减少同步资源的定义
​ 尽量避免嵌套同步

方式三:Lock(锁)

  • 从JDK5.0开始,Java提供了更强大的线程同步机制——通过显示定义同步锁对象来实现同步。同步锁使用Lock对象充当。
  • java.util.concurrent.locks.Lock接口是控制多个线程对共享资源进行访问的工具。锁提供了对共享资源的独占访问,每次只能有一个线程对Lock对象加锁,线程开始访问共享资源之前应先获得Lock对象。
  • ReentrantLock类实现了Lock,它拥有与synchronized相同的并发性和内存语义,在实现线程安全的控制中,比较常用的是ReentrantLock,可以显示加锁、释放锁。

1、实例化ReentrantLock对象。
2、调用lock()上锁。
3、调用unlock()释放锁。

class MyRun2 implements Runnable{

    private int ticket = 100;
    private ReentrantLock lock = new ReentrantLock();
    @Override
    public void run() {
        while(true){
            try{
                lock.lock();

                if(ticket > 0){
                    System.out.println(Thread.currentThread().getName()+":"+ticket);
                    ticket--;
                } else {
                    break;
                }
            }finally {
                lock.unlock();
            }
        }
    }
}
public class ThreadTest2 {
    public static void main(String[] args) {
        MyRun2 r1 = new MyRun2();

        Thread t1 = new Thread(r1);
        Thread t2 = new Thread(r1);
        Thread t3 = new Thread(r1);

        t1.setName("线程一");
        t2.setName("线程二");
        t3.setName("线程三");

        t1.start();
        t2.start();
        t3.start();
    }
}

synchronized 与 Lock的异同?

相同:二者都可以解决线程安全问题

不同:
1、Lock是显式锁(手动开启和关闭锁),synchronized是隐式锁,出了作用域自动释放。

​ 2、Lock只有代码块锁,synchronized有代码块锁和方法锁。
​ 3、使用Lock锁,JVM将花费更少的时间来调度线程,性能更好,并且具有更好的扩展性(提供更多的子类)。

线程的通信

涉及到的方法:

  1. wait():一旦执行此方法,当前线程就进入阻塞状态,并释放同步监视器。
  2. notify():一旦执行此方法,就会唤醒被wait()的一个线程,如果有多个线程被wait(),就唤醒优先级高的。
  3. notifyAll():一旦执行此方法,就会唤醒所有被wait()的线程。

下面举个例子,让两个线程依次交替输出1到100;

class MyThread2 extends Thread{
    private static int number = 1;
    @Override
    public void run() {
        while(true){
            synchronized(MyThread2.class){
                MyThread2.class.notify();
                if(number <= 100){
                    System.out.println(getName()+" : "+number);
                    number++;
                    
                    try {
                        sleep(10);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    
                    try {
                        MyThread2.class.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    
                } else {
                    break;
                }
            }
        }
    }
}
public class CommunicationTest {
    public static void main(String[] args) {
        MyThread2 t1 = new MyThread2();
        MyThread2 t2 = new MyThread2();

        t1.setName("线程一");
        t2.setName("线程二");

        t1.start();
        t2.start();
    }
}

说明:

  1. wait(),notify(),notifyAll()三个方法必须使用在同步代码块或同步方法中。
  2. wait(),otify(),notifyAll()三个方法的调用者必须时同步代码块或同步方法中的同步监视器。否则会出现异常
  3. wait(),otify(),notifyAll()三个方法定义在java.lang.Object类中。

sleep()和wait()的异同?

相同点:一旦执行方法,都可以使当前线程进入堵塞状态。
不同点:1、两个方法声明的位置不同:Thread类中声明sleep(),Object类中声明wait()。
2、调用的要求不同,sleep()可以在任何需要的场景下调用,wait()必须使用在同步代码块或同步方法中。
3、是否释放同步监视器:如果两个方法都在同步代码块或同步方法中使用,sleep()不会释放锁,wait()会释放锁。

相关学习资料的推荐

1.基础知识视频

尚硅谷的Java基础教学视频的多线程部分
通看下来,内容详实且有相应的实践,本文即是本人观看此视频整理的笔记。

2.相关书籍

(等我看过相关的书再来推荐把。

你可能感兴趣的