java多线程总结

最新推荐文章于 2023-09-22 10:57:28 发布

一个头发贼多的菜鸡程序猿

最新推荐文章于 2023-09-22 10:57:28 发布

阅读量185

点赞数

分类专栏：多线程文章标签： java 多线程

本文链接：https://blog.csdn.net/weixin_43274171/article/details/86029264

版权

多线程专栏收录该内容

1 篇文章 0 订阅

订阅专栏

说到多线程就不得不先说一下什么是进程和线程
一、进程和线程的基本概念
**进程：**一个进程相当于一个正在运行的程序，
特点：1、进程是程序运行的基本单位（一个程序至少拥有一个进程）
2、进程拥有独立的系统资源（内存，cpu，磁盘……），同一份程序可以有几个进程，但是这样浪费内存，cpu的负担较重
3、一个程序可以拥有多个进程
**线程：*进程是由线程组成的，一个进程可以拥有多条线程，但是必须有一个主线程（main方法）
* 1、线程不能离开进程而独立存活
2、系统不会为线程分配资源
3、多线程共享进程的资源(比如：代码、数据)，所以线程又被称为轻量级进程(lightweight process)。

线程的五种状态：
新生状态(New)

  用new关键字建立一个线程对象后，该线程对象就处于新生状态。处于新生状态的线程有自己的内存空间，通过调用start方法进入就绪状态。

就绪状态(Runnable)

  处于就绪状态的线程已经具备了运行条件，但是还没有被分配到CPU，处于“线程就绪队列”，等待系统为其分配CPU。就绪状态并不是执行状态，当系统选定一个等待执行的Thread对象后，它就会进入执行状态。一旦获得CPU，线程就进入运行状态并自动调用自己的run方法。有4中原因会导致线程进入就绪状态：

  1. 新建线程：调用start()方法，进入就绪状态;

  2. 阻塞线程：阻塞解除，进入就绪状态;

  3. 运行线程：调用yield()方法，直接进入就绪状态;

  4. 运行线程：JVM将CPU资源从本线程切换到其他线程。

运行状态(Running)

  在运行状态的线程执行自己run方法中的代码，直到调用其他方法而终止或等待某资源而阻塞或完成任务而死亡。如果在给定的时间片内没有执行结束，就会被系统给换下来回到就绪状态。也可能由于某些“导致阻塞的事件”而进入阻塞状态。

阻塞状态(Blocked)

  阻塞指的是暂停一个线程的执行以等待某个条件发生(如某资源就绪)。有4种原因会导致阻塞：

  1. 执行sleep(int millsecond)方法，使当前线程休眠，进入阻塞状态。当指定的时间到了后，线程进入就绪状态。

  2. 执行wait()方法，使当前线程进入阻塞状态。当使用nofity()方法唤醒这个线程后，它进入就绪状态。

  3. 线程运行时，某个操作进入阻塞状态，比如执行IO流操作(read()/write()方法本身就是阻塞的方法)。只有当引起该操作阻塞的原因消失后，线程进入就绪状态。

  4. join()线程联合: 当某个线程等待另一个线程执行结束后，才能继续执行时，使用join()方法。

死亡状态(Terminated)

  死亡状态是线程生命周期中的最后一个阶段。线程死亡的原因有两个。一个是正常运行的线程完成了它run()方法内的全部工作; 另一个是线程被强制终止，如通过执行stop()或destroy()方法来终止一个线程(注：stop()/destroy()方法已经被JDK废弃，不推荐使用)。

  当一个线程进入死亡状态以后，就不能再回到其它状态了。

二、线程与进程的区别

每个进程都有独立的代码和数据空间(进程上下文)，每个线程有独立的运行栈和程序计数器(PC)，进程间的切换会有较大的开销，线程切换的开销小。
进程是资源分配的单位，线程是调度和执行的单位。
多进程: 在操作系统中同时运行多个任务(程序)。
多线程: 在同一应用程序中多个顺序流同时执行。
线程是进程的一部分，进程由线程组成的，所以线程有的时候被称为轻量级进程。
一个没有线程的进程是可以被看作单线程的，如果一个进程内拥有多个线程，线程的执行顺序是不一定的，是抢占式运行，谁先抢到谁就先执行。
系统在运行的时候会为每个进程分配不同的内存区域，但是不会为线程分配内存(线程所使用的资源是它所属的进程的资源)，线程组只能共享资源。

三、如何实现多线程
①通过继承Thread类，然后重写run()方法（局限性：java类间只能单继承）

public class MyThread extends Thread {
@Override
public void run() {
    for (int i = 0; i < 10; i++) {
        System.out.println(Thread.currentThread().getName()+":"+i);
    }
}

}

通过start方法进行调用

public class Test {
    public static void main(String[] args) {
        MyThread myThread = new MyThread();
        myThread.start();
        for (int i = 0; i < 10; i++) {
            System.out.println("main："+i);
        }
    }
}

运行结果：每次结果可能不一样

main：0
main：1
main：2
main：3
main：4
main：5
main：6
main：7
main：8
main：9
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

②通过实现Runnable接口，然后重写run方法

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

通过调用Thread的有参构造方法创建Thread对象，传入new出的线程对象，用start方法启动

public class Test {
    public static void main(String[] args) {
        MyThread myThread = new MyThread();
        new Thread(myThread).start();
        for (int i = 0; i < 10; i++) {
            System.out.println("main："+i);
        }
    }
}

③实现Callable接口，和Runnable接口不一样的是,Callable提供了一个call(),并且call()有返回值，还可以抛出异常
在jdk5以后，提供了一个接口Future 作为Callbale接口中call()的返回值
并且给Future 提供了一个实现类：FutureTask
public class FutureTask implements RunnableFuture
public interface RunnableFuture extends Runnable, Future

public class MyThread implements Callable<Integer> {

    @Override
    public Integer call() throws Exception {
        return 1;
    }
}

通过FutureTask类中的start方法启动线程

public class Test {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        MyThread myThread = new MyThread();
        FutureTask<Integer> integerFutureTask = new FutureTask<>(myThread);
        new Thread(integerFutureTask).start();
        Integer integer = integerFutureTask.get();
        /**
         * 调用get方法：线程会进入阻塞状态
         */
        System.out.println("callable返回值："+integer);
    }
}

四、终止线程
可以用jdk中提供的stop()/destroy()方法，但是不建议使用，属于已经被抛弃的方法，我们通常提供一个boolean类型的变量，当变量值为false，就终止线程的运行。

public class MyThread implements Runnable {
    String name;
    boolean live = true;// 标记变量，表示线程是否可中止；
    public void run() {
        int i = 0;
        //当live的值是true时，继续线程体；false则结束循环，继而终止线程体；
        while (live) {
            System.out.println(name + (i++));
        }
    }
    public void terminate() {
        live = false;
    }
    public static void main(String[] args) {
        MyThread t = new MyThread();
        Thread t1 = new Thread(t);// 新生状态
        t1.start();// 就绪状态
        for (int i = 0; i < 100; i++) {
            System.out.println("main" + i);
        }
        t.terminate();
        System.out.println("stop!");
    }
}

五、线程常用方法
1. sleep()：可以让正在运行的线程进入阻塞状态，直到休眠时间满了，进入就绪状态。
2. yield()：可以让正在运行的线程直接进入就绪状态，让出CPU的使用权。
3. join()：插队，可以让一个线程优先执行
4. isAlive()：判断线程是否被终止
5. getPriority()：获得线程优先级数值
6. setPriority()：设置线程的优先级数值
7. setName()：设置线程名字
8. getName()：获取线程名字
9. currentThread()：获取正在运行的线程对象
10.wait()：线程一直等待
11.wait(毫秒数)：线程等待多长时间
12.notify：唤醒正在等待的线程
13.notifyAll：唤醒所有正在等待的线程，让它们按照优先级执行

六、线程同步
多个线程使用同一个对象，线程同步其实就是一种等待机制，多个需要同时访问此对象的线程进入这个对象的等待池形成队列，等待前面的线程使用完毕后，下一个线程再使用
有时候因为线程同步就会导致线程不安全的情况，所以由此有了同步锁：synchronized来保证线程安全
* synchronized：可以锁对象、方法
* synchronized(对象){
* 同步的代码
* }
* 方法:
* private synchronized void test() {}

用火车站售票来举例，如果不加锁的话，可能会出现多个窗口操作同一张票的情况

public class Ticket extends Thread {
    static private Integer ticket = 20;
    @Override
    public void run() {
        while (true) {
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            if (ticket > 0) {
                System.out.println(Thread.currentThread().getName() + "卖票" + ticket--);
            } else {
                break;
            }
        }
    }
}


public class Test {
    public static void main(String[] args) {
        Ticket ticket = new Ticket();
        ticket.start();
        Thread t1 = new Thread(ticket, "窗口1");
        t1.start();
        Thread t2 = new Thread(ticket, "窗口2");
        t2.start();
        Thread t3 = new Thread(ticket, "窗口3");
        t3.start();
        Thread t4 = new Thread(ticket, "窗口4");
        t4.start();
    }
}

结果：

窗口3卖票20
窗口1卖票18
窗口4卖票20
窗口2卖票19
窗口2卖票17
窗口4卖票16
窗口1卖票15
窗口3卖票14
窗口4卖票13
窗口1卖票12
窗口3卖票11
窗口2卖票13
窗口3卖票10
窗口4卖票8
窗口1卖票9
窗口2卖票10
窗口4卖票7
窗口3卖票4
窗口2卖票6
窗口1卖票5
窗口2卖票2
窗口4卖票1
窗口3卖票2
窗口1卖票3

这就是因为如果不加锁的话，可能会有两个线程进来时票数都是这个数据，从而导致对这张票进行了多次操作，这就导致了线程不安全
而加上锁以后，同一份资源在被其他线程操作时，这个线程不能在用这个资源，避免了同一张票被多次操作的情况
synchronized 方法控制对“对象的类成员变量”的访问：每个对象对应一把锁，每个 synchronized 方法都必须获得调用该方法的对象的锁方能执行，否则所属线程阻塞，方法一旦执行，就独占该锁，直到从该方法返回时才将锁释放，此后被阻塞的线程方能获得该锁，重新进入可执行状态。

public void run() {
        while (true) {
            synchronized (this){
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                if (ticket > 0) {
                    System.out.println(Thread.currentThread().getName() + "卖票" + ticket--);
                } else {
                    break;
                }
            }
        }
    }

结果：

 	窗口1卖票20
    窗口1卖票19
    窗口1卖票18
    窗口1卖票17
    窗口1卖票16
    窗口1卖票15
    窗口1卖票14
    窗口1卖票13
    窗口1卖票12
    窗口4卖票11
    窗口3卖票10
    窗口2卖票9
    窗口3卖票8
    窗口4卖票7
    窗口4卖票6
    窗口4卖票5
    窗口4卖票4
    窗口4卖票3
    窗口4卖票2
    窗口4卖票1

七、死锁
多个线程各自占有一些共享资源，并且互相等待其他线程占有的资源才能进行，而导致两个或者多个线程都在等待对方释放资源，都停止执行的情形
例如：

public class 死锁 {
    /**
     * 由于同步锁操作不当产生
     * 案例：哥哥 妹妹 绑匪
     * 哥哥说：你放了我妹妹 我给你500万
     * 绑匪说：你先给我500万，我就放了你妹妹
     */
    public static void main(String[] args) {
        MyThread t1 = new MyThread("哥哥");
        t1.start();
        MyThread t2 = new MyThread("劫匪");
        t2.start();

    }
}
public class GeGe {
    public void speak(){
        System.out.println("你放了我妹妹 我给你500万");
    }
    public void success(){
        System.out.println("救出妹妹，损失500万");
    }
}
public class JieFei {
    public void speak(){
        System.out.println("你先给我500万，我就放了你妹妹");
    }
    public void success(){
        System.out.println("放了妹妹，得到500万");
    }
}
public class MyThread extends Thread {
    static GeGe gege = new GeGe();
    static JieFei jieFei = new JieFei();
    String name;
    public MyThread(String name) {
       this.name = name;
    }
    @Override
    public void run() {
            if(name.equals("哥哥")){
                synchronized (gege){
                 gege.speak();
                    synchronized (jieFei){
                        jieFei.success();
                    }
                }
            }else {
                synchronized (jieFei){
                    jieFei.speak();
                    synchronized (gege){
                        gege.success();
                    }
                }
            }
    }
}

结果：
在这里插入图片描述
死锁是由于“同步块需要同时持有多个对象锁造成”的，解决死锁的思路就是：同一个代码块，不要同时持有两个对象锁。