【Java基础】多线程（详细内容总结）

写一封信

于 2019-07-28 20:49:44 发布

阅读量259

点赞数 1

文章标签：多线程

本文链接：https://blog.csdn.net/LJL55555/article/details/97618682

版权

**【java】** 专栏收录该内容

37 篇文章 0 订阅

订阅专栏

一、线程

线程 vs 进程

1、联系

线程 – 进程

线程是进程的组成部分，一个进程可以拥有多个线程，一个线程必须有一个父进程
线程可以拥有自己的堆栈、程序设计器、局部变量，但不拥有系统资源，与父进程的其他线程共享该进程所拥有的全部资源

线程 – 线程

独立运行，它并不知道进程中是否还有其他线程存在
执行是抢占式（当前运行的线程在任何时候都可能被挂起，以便另一个线程可以运行）

2、区别

进程

操作系统支持同时运行多个任务，每个任务（程序）就是进程
处于运行过程中的程序，具有一定的独立功能（独立性、动态性、并发性）
系统进行资源分配和调度的一个独立单位

线程

当一个程序运行时，内部可能包含多个顺序执行流，每个顺序执行流就是一个线程

二、多线程

1、为什么会有多线程

单线程

程序的功能有限，不能满足不同客户端之间互不干扰的要求

多线程

共享内存：进程间不能，线程间很容易
效率：系统创建进程时需要为该进程重新分配系统资源，线程数据可共享（进程代码块、进程的共有数据…），因此多线程的多任务并发比多进程效率高
编程难度：Java语言内置了多线程功能支持，不是单纯地作为底层操作系统的调度方式，因此简化了Java的多线程编程

2、怎么使用多线程

2.1 生命周期

状态转换图
在这里插入图片描述
详细解释

2.2 线程的创建和启动

方法：

1、继承 Thread

步骤：

定义Thread类的子类，重写该类run方法
创建Thread子类的实例（创建线程对象）
调用线程对象的start()方法来启动该线程

用到的方法：

Thread.currentThread()：返回当前正在执行的线程对象
getName()：返回调用该方法的线程名字
实例：

public class FirstThread extends Thread {                                 
    private int i;                                                        
                                                                          
    @Override                                                             
    public void run() {                                                   
        for (; i < 100; i++) {                                            
            System.out.println(getName() + "" + i);                       
        }                                                                 
    }                                                                     
                                                                          
    public static void main(String[] args) {                              
        for (int i = 0; i < 100; i++) {                                   
            System.out.println(Thread.currentThread().getName() + "" + i);
            if (i == 20) {                                                
                new FirstThread().start();                                
                new FirstThread().start();                                
            }                                                             
        }                                                                 
    }                                                                     
}

2、实现Runnable接口

Runnable接口是函数式接口，可使用Lambda表达式创建Runnable对象

步骤

定义Runnable接口的实现类，重写该接口run方法
创建Runnable实现类的实例，并以此实例作为Thread的target来创建Thread对象
调用线程对象的start()方法来启动该线程

实例

public class SecondThread implements Runnable {                             
    private int i;                                                          
                                                                            
    @Override                                                               
    public void run() {                                                     
        for (; i < 100; i++) {                                              
            System.out.println(Thread.currentThread().getName() + " " + i); 
        }                                                                   
    }                                                                       
                                                                            
    public static void main(String[] args) {                                                                                                         
        for (int i = 0; i < 100; i++) {                                     
            System.out.println(Thread.currentThread().getName() + " " + i); 
            if (i == 20) {                                                  
                SecondThread st = new SecondThread();                       
                new Thread(st, "新线程1").start();                             
                new Thread(st, "新线程2").start();                             
            }                                                               
        }                                                                   
    }                                                                       
}

3、使用Callable和Future创建线程（有返回值，可抛异常）

Future接口来代表Callable接口里call方法的返回值，并为Future接口提供了一个FutureTask实现类，该实现类实现了Future接口

步骤：

定义Callable接口的实现类，重写call方法
使用FutureTask类来包装Callable对象（该FutureTask对象封装了该Callable对象的call方法的返回值）
调用FutureTask对象的get方法来获得子线程执行结束后的返回值

实例：

public class ThirdThread {                                                      
    public static void main(String[] args) {                                    
        FutureTask<Integer> task = new FutureTask<>((Callable<Integer>) () -> { 
            int i = 0;                                                          
            for (; i < 100; i++) {                                              
                System.out.println(Thread.currentThread().getName() + " " + i); 
            }                                                                   
            return i;                                                           
        });                                                                     
        for (int i = 0; i < 100; i++) {                                         
            System.out.println(Thread.currentThread().getName() + " " + i);     
            if (i == 20) {                                                      
                new Thread(task, "有返回值的线程").start();                            
            }                                                                   
        }                                                                       
        try {                                                                   
            System.out.println("子线程的返回值：" + task.get());                        
        } catch (Exception ex) {                                                
            ex.printStackTrace();                                               
        }                                                                       
    }                                                                           
}

对比：
在这里插入图片描述

2.3 控制线程

1、join线程

join 指一个线程等待另一个线程完成（当调用join方法，调用线程将被阻塞，直到join方法加入的join线程执行完为止）。常用于将大问题划分成许多小问题，每个小问题分配一个线程。当所有小问题得到处理后，再调用主进程来进一步操作。

实例

public class JoinThread extends Thread{
    public JoinThread(String name){
        super(name);
    }
    @Override
    public void run(){
        for (int i = 0; i < 100; i++) {
            System.out.println(getName()+" "+ i );
        }
    }
    public static void main(String[] args) throws InterruptedException {
        new JoinThread("新线程：").start();
        for (int i = 0; i < 100; i++) {
            if (i == 20) {
                JoinThread jt = new JoinThread("被join的线程");
                jt.start();
                jt.join();
            }
            System.out.println(Thread.currentThread().getName() + " " + i);
        }
    }
}

2、后台线程（setDaemon）

后台线程会为其他线程提供服务，比如我们常常接触到的JVM的垃圾回收线程。那么我们是怎么使用的呢？ setDaemon(true) 可以将指定线程设置成后台线程，在start方法之前调用。当所有的前台线程死亡时，后台线程随之死亡。前台线程创建的子线程默认是前台线程，后台线程则对应的是后台线程。

3、线程睡眠（sleep-阻塞状态）

sleep 会暂停当前线程。暂停后，会给其他线程执行机会，不会理会优先级。而且抛出InterruptedException异常，调用sleep方法捕捉或抛出该异常。由于 sleep 具有更好的移植性，因此推荐使用。

4、线程让步（yield-就绪状态）

yield 会暂停当前线程。暂停后，只会给优先级相同，或优先级更高的线程执行机会，而且没有声明抛出任何异常。

5、改变线程优先级

用到的方法是 setPriority。它的范围是1-10，默认5。我们需要知道子线程默认的优先级与父类相同。

2.4 线程同步（安全）

为什么要有线程同步？这是因为线程调度不稳定，程序可能出现错误。

那么我们应该如何解决这一问题呢？

可以使用同步监视器（synchronized），主要用于同步代码块或者同步方法，此外，还可以用 lock。
在这里插入图片描述

可能产生的问题：这个时候我们就不得不考虑死锁的问题，死锁的产生是因为两个线程相互等待对方释放同步监视器，死锁的特征是一旦出现死锁，程序没有异常，没有提示，这时所有线程处于阻塞状态，无法继续。