Java多线程基础

2022-04-30  本文已影响0人  张氏小毛驴

一. 进程和线程概念

二. 线程的创建

Java中使用java.lang.Thread类代表线程，所有的线程对象都必须是Thread类或其子类的实例。

1.Java中有两种方式创建线程：

注意：关于Thread类的start()和run()方法

  1. start()方法是用来启动新建的线程，run()方法只是一个普通方法，直接调用run()方法并不会创建线程，程序仍旧是在当前线程中运行。
  2. start()方法不能重复调用，而run()可以。
  3. start()内部调用了run()方法，star()里面的run代码可以不执行完就继续执行下面的代码（也就是进行了线程切换），而直接调用run()方法，就必须等待全部代码执行完才能继续往下执行(跟普通方法一样)

2.两种创建方式的对比

推荐使用实现Runnable接口的方式创建多线程，主要是实现Runnable接口的方式比较具有优势，主要为：

三.线程的状态

Java线程有六种状态，在java.lang.Thread.State中给出了六种线程状态：

对应状态转换图如下：

[图片上传失败...(image-fa87ec-1651323784498)]

四.线程类Thread常用的方法

五.线程同步与通信

当有多个线程同时运行时，如果每个线程都要访问共有资源，就可能造成线程安全问题。

比如典型的多线程售票问题，多个线程同时售票，但票的总数是一定的，每个线程卖出了票都会更新总票数，同时进行就可能造成了数据混乱了。

线程安全问题都是由全局变量及静态变量引起的。

1.线程同步

线程同步机制(synchronized)是Java中提供的一种解决线程安全问题的方式。

2.线程通信

上述线程同步针对的是多个线程共享同一个资源的情况，线程间通信则是指多个线程共同处理同一个资源，但是彼此的执行动作是不一样的。

典型的例子就是生产者与消费者的问题了。

比如：线程A是生产者，用来生产包子，线程B是消费者，用来吃包子，包子就是他们共享的同一资源，但线程A和线程B的动作是不一样的，一个负责生产，一个负责消费，这就存在双方通信问题了。

Java中有一个内建的等待机制来允许线程在等待信号的时候变成非运行状态，java.lang.Object类定义了三个方法来实现这个等待机制：wait()、notify()、notifyAll()

wait()：线程不再活动，不再参与调度，进入wait set中，因此不会浪费CPU资源，也不会去竞争锁，这时线程在等待别的线程执行一个“通知(notify)”的动作。线程被唤醒后重新进入到调度队列。

notify()：选取所通知对象的wait set中的一个线程释放。（随机选择）

notifyAll()：释放所通知对象的wait set上的全部线程。

一个线程一旦调用了任意对象的wai()方法，就会变成非运行状态，直到另一个线程调用了同一个对象的notify()方法/notifyAll()方法，为了调用wait()或者notify()，线程就必须先获得那个对象的锁，因此线程必须是在同步块里调用wait()或者notify()

所以调用wait和notify方法需要注意以下细节：

注意：

即使notify只通知了一个等待的线程，被通知的线程也不能立即恢复运行，因为当初中断的地方是在同步块内，而此刻它已经不再具有锁了，所以需要重新去获取锁（这就面临竞争），获取成功后才会在wait方法之后恢复执行。

代码演示生产者生产包子，消费者吃包子

资源——包子

public class Resource {
    String pi;              // 包子皮
    String xian;            // 包子馅
    boolean flag = false;   // 包子资源是否存在
}

生产者——包子铺

public class Productor extends Thread {
    private Resource baozi;

    public Productor(String name, Resource bz) {
        super(name);
        this.baozi = bz;
    }

    @Override
    public void run() {
        // 做包子
        synchronized (baozi) {
            while(true) {
                // 有包子，那就等待
                if (baozi.flag == true) {
                    try {
                        baozi.wait();
                    } catch(InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                // 没有包子，做包子
                System.out.println("生产者开始制作包子...");
                baozi.pi = "薄皮";
                baozi.xian = "牛肉";
                baozi.flag = true;
                System.out.println("包子做好了：" + baozi.pi + baozi.xian);
                try {
                    Thread.sleep(1000);
                } catch(InterruptedException e) {
                    e.printStackTrace();
                }
                // 唤醒等待线程
                baozi.notify();
            }
        }
    }
}

消费者——吃包子的人

public class Consumer extends Thread {
    private Resource baozi;

    public Consumer(String name, Resource bz) {
        super(name);
        this.baozi = bz;
    }

    @Override
    public void run() {
        while (true) {
            synchronized (baozi) {
                if (baozi.flag == false) {  // 没有包子可以吃， 那就等待
                    try {
                        baozi.wait();
                    } catch(InterruptedException e) {
                        e.printStackTrace();
                    }
                   
                }
                System.out.println("消费者正在吃" + baozi.pi + baozi.xian + "包子");
                System.out.println("======================");
                baozi.flag = false;
                baozi.notify();
            }
        }
    }
}

测试主类：

public class Demo {
    public static void main(String[] args) {
        Resource baozi = new Resource();

        // 两个线程都用同一资源，作为线程的锁对象
        Productor productor = new Productor("生产者", baozi);
        Consumer consumer = new Consumer("消费者", baozi );

        consumer.start();
        productor.start();
    }
}

六. 线程池

  1. 为啥要用线程池？

    因为当我们需要用到线程时候就创建一个，实现起来是很方便的，但会有个问题，那就是当并发的线程数很多时候，而且任务是比较短的结束，这样频繁的创建线程就会降低系统的效率了，因为系统创建线程和销毁线程都是需要时间的。

    所以可以使用线程池来实现这样的效果：在线程执行完一个任务后，并不去销毁，而是可以继续执行其他的任务。

  2. 线程池概念

    线程池其实就是一个容器，可以容纳多个线程，这里面的线程可以反复使用，不用频繁创建新的线程，降低资源消耗，提高响应速度，提高线程的可管理性。

  3. 线程池的使用

    Java里面线程池的顶级接口是：java.util.concurrent.Executor,但严格意义上讲，Executor并不是一个线程池，而是一个执行线程的工具，真正的线程池接口是：java.util.concurrent.ExecutorService

    官方建议使用的是java.util.concurrent.Executors工程类来创建线程池对象

    主要方法是：

    • public static ExecutorService newFixedThreadPool(int nThreads)：返回线程池对象。（创建的是有界的线程池，可以指定线程池线程的最大个数）

    • public Future<?> submit(Runnable task)：获取线程池中的某一个对象，并执行

      Future接口：用来记录线程任务执行完毕后产生的结果。

    使用线程池中线程对象的步骤：

    • 创建线程池对象
    • 创建Runnable接口子类对象(任务)
    • 提交Runnable接口的子类对象
    • 关闭线程池（一般不做）

    示例代码：

    public class Task implements Runnable {
    @Override
    public void run() {
        System.out.println("我要一个教练");
        try {
            Thread.sleep(1000);
        } catch(InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("教练来了：" + Thread.currentThread().getName());
        System.out.println("教我游泳，教完后，教练回到了游泳池");
    }
}

    import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class ThreadPoolDemo {
    public static void main(String[] args) {
        // 创建线程池对象
        ExecutorService service = Executors.newFixedThreadPool(2);
        // 创建Runnable实例对象
        Task t = new Task();

        // 从线程池中获取线程对象，然后调用Task中的run方法
        service.submit(t);
        // 再获取线程对象
        service.submit(t);
        service.submit(t);

        // 关闭线程池
        // service.shutdown();
    }
}
上一篇 下一篇

猜你喜欢

热点阅读