Java多线程详解

最新推荐文章于 2024-08-15 23:35:35 发布

KEY_GSY

最新推荐文章于 2024-08-15 23:35:35 发布

阅读量141

点赞数 1

分类专栏： java基础文章标签：多线程 java 并发编程多进程 thread

本文链接：https://blog.csdn.net/weixin_43404016/article/details/104915856

版权

java基础专栏收录该内容

24 篇文章 0 订阅

订阅专栏

要想了解多线程，首先要知道线程是什么，它和程序，进程之间的差别。
程序：就是一个静态的代码块，静态的对象。
进程：就是一个程序执行的过程或者是一个正在运行的程序，比如电脑里面运行的qq，或者运行的浏览器。每个独立执行的程序都可以叫做一个进程
线程：就是在进程里同时做不同的事情，比如在QQ里面既要发送消息，还要接收消息，这就是不同的线程。

多线程在java中实现的两种方法
(1). 继承Thread类

 1.创建一个集成于Thread类的子类 （通过ctrl+o（override）输入run查找run方法）
   2.重写Thread类的run（）方法
   3.创建Thread子类的对象
  4.通过此对象调用start（）方法

先通过一个经典的售票例子来实现多线程：

public class TicketOffice extends Thread {

    private static int ticket = 100;

    @Override
    public void run(){
        while(true){
            if(ticket>0){
                System.out.println(getName()+"当前售出第"+ticket+"张票");
                ticket--;
            }else{
                break;
            }
        }
    }

}

public class TheadDemo {

    public static void main(String args[]){

        TicketOffice t1 = new TicketOffice();
        TicketOffice t2 = new TicketOffice();
        TicketOffice t3 = new TicketOffice();

        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");

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

}

运行结果
我们会发现结果有错误的，出现了同一张票同时销售多次的状况。

(2). 通过实现Runable接口

1.创建一个实现了Runable接口的类
2.实现类去实现Runnable中的抽象方法：run()
3.创建实现类的对象
4.将此对象作为参数传递到Thread类中的构造器中，创建Thread类的对象
5.通过Thread类的对象调用start（）
也是通过售票来模拟线程

public class TicketOffice2 implements Runnable {

    private static int ticket = 100;

    @Override
    public void run() {
        while(true){
            if(ticket>0){
                System.out.println(Thread.currentThread().getName()+"当前售出第"+ticket+"张票");
                ticket--;
            }else{
                break;
            }
        }
    }
}

public static void main(String args[]){

       TicketOffice2 ticketOffice2 = new TicketOffice2();

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

        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");

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

    }


}

运行结果：

继承Thread和实现Runable接口的运行结果都是相同的；
但是比较推荐使用实现Runable接口；主要是因为Java单继承的特性；
实现Runable的方式更适合用来处理多个线程有共享数据的情况；
但是两种方式都是需要重写run()方法的。

锁
java中有两种锁，一种是重量级锁synchronized，jdk1.6经过锁优化加入了偏向锁和轻量级锁，一种是JUC并发包下的Lock锁，synchronized锁也称对象锁，每个对象都有一个对象锁。这里通过加锁的方式实现线程安全。
synchronized使用方法：
Synchronized（同步监视器）{
//需要被同步的代码
}
继续使用上个例子来实现数据同步；

public class TicketOffice2 implements Runnable {

    private static int ticket = 100;

    @Override
    public  synchronized void run() {
        while(true){
            if(ticket>0){
                System.out.println(Thread.currentThread().getName()+"当前售出第"+ticket+"张票");
                ticket--;
            }else{
                break;
            }
        }
    }
}

public class ThreadDemo2 {


    public static void main(String args[]){

       TicketOffice2 ticketOffice2 = new TicketOffice2();

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

        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");

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

    }


}

实现效果

加上关键字之后就不会出现同一个票多次出售的情况；

线程间的通信

package com.gsy.springrabbitmq.bean;

import java.util.ArrayList;
import java.util.List;

/**
 * @program: springboot-rabbitmq
 * @description:
 * @author: GSY
 * @create: 2020-03-17 14:47
 **/
public class MyList {
    private List list = new ArrayList<>();

    public void add() {
        list.add("HelloWorld");
    }

    public int size() {
        return list.size();
    }

    public static void main(String[] args) {
        final MyList myList = new MyList();

        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                myList.add();
                System.out.println("当前线程，" + Thread.currentThread().getName() + "添加了一个元素");
            }
        }, "t1");

        Thread t2 = new Thread(() -> {
            while (true) {

                if (myList.size() == 5) {
                    System.out.println("当前线程收到通知：" + Thread.currentThread().getName() + "list size = 5线程停止。。。");
                    throw new RuntimeException();
                }
            }
        }, "t2");
        t1.start();
        t2.start();
    }
}

运行结果
在这里插入图片描述
虽然两个线程间实现了通信，但有一个弊端就是，线程t2不断的通过while（true）语句轮询机制来检测某一个条件，这样会造成很严重的CPU浪费。所以就需要有一种机制来实现减少CPU的资源浪费，而且还可以实现在多个线程间通信，它就是“wait/notify”机制。

package com.gsy.springrabbitmq.bean;

import java.util.LinkedList;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;

/**
 * @program: springboot-rabbitmq
 * @description:
 * @author: GSY
 * @create: 2020-03-17 14:56
 **/
public class MyQueue {

    private LinkedList<Object> list = new LinkedList<>();

    //2.需要一个计数器
    private AtomicInteger count = new AtomicInteger();

    //3.需要指定上限和下限
    private final int minSize = 0;
    private final int maxSize;

    //4.构造方法
    public MyQueue(int size){
        this.maxSize = size;
    }

    //5.初始化一个对象，用于加锁
    private final Object lock = new Object();

    //6.put()把anObject加到BlockingQueue里，如果BlockQueue没有空间，则调用此方法的线程被阻断，知道BlockingQueue里面有空间再继续
    public void put(Object obj){
        synchronized (lock){
            while (count.get() == this.maxSize){
                try {
                    lock.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            //6.1 加入元素
            list.add(obj);
            //6.2 计数器累加
            count.incrementAndGet();
            System.out.println("新加入的元素为："+obj);
            //6.3 通知另外一个线程(唤醒)
            lock.notify();
        }
    }

    //7.take:取走BlockingQueue里排在首位的对象，若BlockingQueue为空，阻断进入等待状态直到BlockingQueue有新的数据被加入
    public Object take(){
        Object ret;
        synchronized (lock){
            while(count.get() == this.minSize){
                try {
                    lock.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            //7.1 移除元素
            ret = list.removeFirst();
            //7.2 计数器递减
            count.decrementAndGet();
            //7.3 唤醒另外一个线程
            lock.notify();
        }
        return ret;
    }

    public int getSize(){
        return this.count.get();
    }


    public static void main(String[] args) {
        MyQueue mq = new MyQueue(5);
        mq.put("a");
        mq.put("b");
        mq.put("c");
        mq.put("d");
        mq.put("e");
        System.out.println("当前容量的长度："+mq.getSize());

        Thread t1 = new Thread(()->{
            mq.put("f");
            mq.put("g");
        },"t1");

        t1.start();

        Thread t2 = new Thread(()->{
            Object o1 = mq.take();
            System.out.println("移除的元素为"+o1);
            Object o2 = mq.take();
            System.out.println("移除的元素为"+o2);
        },"t2");

        try {
            TimeUnit.SECONDS.sleep(2);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        t2.start();
    }
}

效果

使用wait/notify方法实现线程间通信，要注意以下两点：
(1) wait和notify必须配合synchronized关键字使用
(2)wait方法释放锁，notify方法不释放锁

sleep()和wait()方法的异同
相同点：一旦执行方法以后，都会使得当前的进程进入阻塞状态
不同点：

1.两个方法声明的位置不同，Thread类中声明sleep，Object类中声明wait。
2.调用的要求不同，sleep可以在任何需要的场景下调用，wait必须使用在同步代码块或者同步方法中
3.关于是否释放同步监视器，如果两个方法都使用在同步代码块或同步方法中，sleep不会释放，wait会释放

start()方法和run()方法的差别
只有调用了start()方法，才会表现出多线程的特性，不同线程的run()方法里面的代码交替执行。如果只是调用run()方法，那么代码还是同步执行的，必须等待一个线程的run()方法里面的代码全部执行完毕之后，另外一个线程才可以执行其run()方法里面的代码。
Java中线程状态
（1）新建状态：即单纯地创建一个线程，创建线程有三种方式
（2）就绪状态：在创建了线程之后，调用Thread类的start()方法来启动一个线程，即表示线程进入就绪状态！
（3）运行状态：当线程获得CPU时间，线程才从就绪状态进入到运行状态！
（4）阻塞状态：线程进入运行状态后，可能由于多种原因让线程进入阻塞状态，如：调用sleep()方法让线程睡眠，调用wait()方法让线程等待，调用join()方法、suspend()方法（它现已被弃用！）以及阻塞式IO方法。
（5）死亡状态：run()方法的正常退出就让线程进入到死亡状态，还有当一个异常未被捕获而终止了run()方法的执行也将进入到死亡状态！

创建状态（New）、就绪状态（Runnable）、运行状态（Running）、阻塞状态（Blocked）、死亡状态（Dead）。