JAVA打怪之路 - 多线程

最新推荐文章于 2024-09-08 10:40:56 发布

爱摸鱼的猫猫

最新推荐文章于 2024-09-08 10:40:56 发布

阅读量228

点赞数 1

分类专栏： # JAVA打怪文章标签：多线程 java 并发编程

本文链接：https://blog.csdn.net/qq_40521599/article/details/103636746

版权

JAVA打怪专栏收录该内容

17 篇文章 0 订阅

订阅专栏

多线程

JAVA多线程是Java面试中比较重要的常考点，而且使用起来也需要有一定的技术功底，这里就是主要讲下多线程的基础知识。

一、基本概念：程序、进程、线程、并发、并行

注1：一个Java应用程序java.exe，其实至少有三个线程：main()主线程，gc()垃圾回收线程，异常处理线程。当然如果发生异常，会影响主线程。

注2：Java中的线程分为两类：一种是守护线程，一种是用户线程。它们在几乎每个方面都是相同的，唯一的区别是判断JVM何时离开。守护线程是用来服务用户线程的，通过在start()方法前调用thread.setDaemon(true)可以把一个用户线程变成一个守护线程。Java垃圾回收就是一个典型的守护线程。若JVM中都是守护线程，当前JVM将退出。
在这里插入图片描述
二、线程的创建和使用 java.lang.Thread

① 继承Thread类

1. 创建一个继承于Thread类的子类
1. 重写Thread类的run() --> 将此线程执行的操作声明在run()中
1. 创建Thread类的子类的对象
1. 通过此对象调用start()
  
  注意点：
  
  ② 实现Runnable接口
1. 创建一个实现了Runnable接口的类
1. 实现类去实现Runnable中的抽象方法：run()
1. 创建实现类的对象（ MThread mThread = new MThread();）
1. 将此对象作为参数传递到Thread类的构造器中，创建Thread类的对象
  （Thread t1 = new Thread(mThread);）
1. 通过Thread类的对象调用start()

//1. 创建一个实现了Runnable接口的类
class MThread implements Runnable{
    //2. 实现类去实现Runnable中的抽象方法：run()
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            if(i % 2 == 0){
                System.out.println(Thread.currentThread().getName() + ":" + i);
            }
        }
    }
}

public class ThreadTest1 {
    public static void main(String[] args) {
        //3. 创建实现类的对象
        MThread mThread = new MThread();
        //4. 将此对象作为参数传递到Thread类的构造器中，创建Thread类的对象
        Thread t1 = new Thread(mThread);
        t1.setName("线程1");
        //5. 通过Thread类的对象调用start():① 启动线程
         // ②调用当前线程的run()-->调用了Runnable类型的target的run()
        t1.start();
        //再启动一个线程，遍历100以内的偶数
        Thread t2 = new Thread(mThread);
        t2.setName("线程2");
        t2.start();
    }
}

注：继承方式和实现方式的联系与区别
public class Thread extends Object implements Runnable{ }
开发中：优先选择：实现Runnable接口的方式
原因： 1. 实现的方式没有类的单继承性的局限性。
2. 实现的方式更适合来处理多个线程有共享数据的情况。
联系 : 两种方式都需要重写run(),将线程要执行的逻辑声明在run()中。

③ JDK5.0新增实现Callable接口

   //1.创建一个实现Callable的实现类
class NumThread implements Callable{
     //2.实现call方法，将此线程需要执行的操作声明在call()中
    @Override
    public Object call() throws Exception {
        int sum = 0;
        for (int i = 1; i <= 100; i++) {
            if(i % 2 == 0){
                System.out.println(i);
                sum += i;
            }
        }
        return sum;
    }
}

public class ThreadNew {
    public static void main(String[] args) {
        //3.创建Callable接口实现类的对象
        NumThread numThread = new NumThread();
        //4.将此Callable接口实现类的对象作为传递到FutureTask构造器中，
        //创建FutureTask的对象
        FutureTask futureTask = new FutureTask(numThread);
        //5.将FutureTask的对象作为参数传递到Thread类的构造器中，创建Thread对象，
         //并调用start()
        new Thread(futureTask).start();
        try {
            //6.获取Callable中call方法的返回值
     //get()返回值即为FutureTask构造器参数Callable实现类重写的call()的返回值。
            Object sum = futureTask.get();
            System.out.println("总和为：" + sum);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}

如何理解实现Callable接口的方式创建多线程比实现Runnable接口创建多线程方式强大？
* 1. call()可以有返回值的。

1. call()可以抛出异常，被外面的操作捕获，获取异常的信息
1. Callable是支持泛型的

④ JDK5.0新增使用线程池
在这里插入图片描述

class NumberThread 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 NumberThread1 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) {
        //1. 提供指定线程数量的线程池
        ExecutorService service = Executors.newFixedThreadPool(10);
        ThreadPoolExecutor service1 = (ThreadPoolExecutor) service;
        //设置线程池的属性
//        System.out.println(service.getClass());
//        service1.setCorePoolSize(15);
//        service1.setKeepAliveTime();
        //2.执行指定的线程的操作。需要提供实现Runnable接口或Callable接口实现类的对象
        service.execute(new NumberThread());//适合适用于Runnable
        service.execute(new NumberThread1());//适合适用于Runnable
//      service.submit(Callable callable);//适合使用于Callable
        //3.关闭连接池
        service.shutdown();
    }
}

三、 java.lang.Thread 类
构造器
Thread()：创建新的Thread对象
Thread(String threadname)：创建线程并指定线程实例名
Thread(Runnable target)：指定创建线程的目标对象，实现Runnable接口中的run方法
Thread(Runnable target, String name)：创建新的Thread对象
方法

1. start(): 启动当前线程；调用当前线程的run()
1. run(): 通常需要重写Thread类中的此方法，将创建的线程要执行的操作声明在此方法中
1. currentThread(): 静态方法，返回执行当前代码的线程
1. getName(): 获取当前线程的名字
1. setName(): 设置当前线程的名字
1. yield(): 释放当前cpu的执行权，线程让步，暂停当前正在执行的线程，把执行机会让给优先级相同或更高的线程
1. join(): 在线程a中调用线程b的join(),此时线程a就进入阻塞状态，直到线程b完全执行完以后，线程a才结束阻塞状态，低优先级的线程也可以获得执行。
1. stop(): 已过时。当执行此方法时，强制结束当前线程。
1. sleep(long millitime): 让当前线程“睡眠”指定的millitime毫秒。在指定的millitime毫秒时间内，当前线程是阻塞状态，抛出InterruptedException异常。
1. isAlive(): 判断当前线程是否存活。
1. getPriority(): 获取线程的优先级（优先级：1 – 10 ）
1. setPriority(int p): 设置线程的优先级
  注：高优先级的线程要抢占低优先级线程cpu的执行权。但是只是从概率上讲，高优先级的线程高概率的情况下被执行。并不意味着只有当高优先级的线程执行完以后，低优先级的线程才执行。
  四、线程的生命周期
  JDK中用Thread.State类定义了线程的几种状态
  要想实现多线程，必须在主线程中创建新的线程对象。Java语言使用Thread类及其子类的对象来表示线程，在它的一个完整的生命周期中通常要经历如下的五种状态：
  ① 新建：当Thread类或其子类的对象被声明并创建时，新生的线程对象处于新建状态
  ② 就绪：处于新建状态的线程被start()后，将进入线程队列等待CPU时间片，此时它已具备了运行的条件，只是没分配到CPU资源
  ③ 运行：当就绪的线程被调度并获得CPU资源时,便进入运行状态， run()方法定义了线程的操作和功能
  ④ 阻塞：在某种特殊情况下，被人为挂起或执行输入输出操作时，让出 CPU 并临时中止自己的执行，进入阻塞状态
  ⑤ 死亡：线程完成了它的全部工作或线程被提前强制性地中止或出现异常导致结束

五、线程的同步

① Synchronized 同步代码块

格式：synchronized (同步监视器){
// 需要被同步的代码；
}

说明：

操作共享数据的代码，即为需要被同步的代码。–>不能包含代码多了，也不能包含代码少了。
共享数据：多个线程共同操作的变量。比如：ticket就是共享数据。
同步监视器，俗称：锁。任何一个类的对象，都可以充当锁。
要求：多个线程必须要共用同一把锁。
补充：在实现Runnable接口创建多线程的方式中，我们可以考虑使用this充当同步监视器。

② Synchronized 方法

格式： public synchronized void show (String name){
….
}

注：
1、操作同步代码时，只能有一个线程参与，其他线程等待。相当于是一个单线程的过程，效率低。 — 局限性
2、同步方法仍然涉及到同步监视器，只是不需要我们显式的声明。
3、非静态的同步方法，同步监视器是：this
静态的同步方法，同步监视器是：当前类本身
在这里插入图片描述

③ Lock锁 — JDK5.0新增
在这里插入图片描述

class A{
     private final ReentrantLock lock = new ReenTrantLock();
     public void m(){
         lock.lock();
         try{
            //保证线程安全的代码;
         }finally{
             //注意：如果同步代码有异常，要将unlock()写入finally语句块
            lock.unlock(); 
         }
     }
}

注：synchronized 与 Lock 的对比
在这里插入图片描述
六、线程通信

在这里插入图片描述

在这里插入图片描述
面试题：sleep() 和 wait()的异同？

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

在这里插入图片描述

class Communication implements Runnable {
    int i = 1;
    public void run() {
        while (true) {
            synchronized (this) {
                notify();
                if (i <= 100) {
                    System.out.println(Thread.currentThread().getName() + ":" + i++);
                } else
                    break;
                try {
                    wait();
                } catch (InterruptedException e) {
        e.printStackTrace();
                }
            }
        }
    }
}

补充：生产者 / 消费者经典问题
生产者(Productor)将产品交给店员(Clerk)，而消费者(Customer)从店员处取走产品，
店员一次只能持有固定数量的产品(比如:20），如果生产者试图生产更多的产品，店员
会叫生产者停一下，如果店中有空位放产品了再通知生产者继续生产；如果店中没有产品了，店员会告诉消费者等一下，如果店中有产品了再通知消费者来取走产品。
这里可能出现两个问题：
生产者比消费者快时，消费者会漏掉一些数据没有取到。
消费者比生产者快时，消费者会取相同的数据。

class Clerk { // 售货员
    private int product = 0;
    public synchronized void addProduct() {
        if (product >= 20) {
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        } else {
            product++;
            System.out.println("生产者生产了第" + product + "个产品");
            notifyAll();
        }
    }
 public synchronized void getProduct() {
    if (this.product <= 0) {
        try {
            wait();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    } else {
        System.out.println("消费者取走了第" + product + "个产品");
        product--;
        notifyAll();
    }
   }
}

class Productor implements Runnable { // 生产者
    Clerk clerk;
    public Productor(Clerk clerk) {
        this.clerk = clerk;
    }
    public void run() {
        System.out.println("生产者开始生产产品");
        while (true) {
            try {
                Thread.sleep((int) Math.random() * 1000);
            } catch (InterruptedException e) {
    e.printStackTrace();
            }
            clerk.addProduct();
        }
    }
}
class Consumer implements Runnable { // 消费者
    Clerk clerk;
    public Consumer(Clerk clerk) {
        this.clerk = clerk;
    }
    public void run() {
        System.out.println("消费者开始取走产品");
        while (true) {
            try {
                Thread.sleep((int) Math.random() * 1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            clerk.getProduct();
        }
    }
}

public class ProductTest { //测试
    public static void main(String[] args) {
        Clerk clerk = new Clerk();
        Thread productorThread = new Thread(new Productor(clerk));
        Thread consumerThread = new Thread(new Consumer(clerk));
        productorThread.start();
        consumerThread.start();
    }
}

爱摸鱼的猫猫

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
JAVA打怪之路 - 多线程

多线程JAVA多线程是Java面试中比较重要的常考点，而且使用起来也需要有一定的技术功底，这里就是主要讲下多线程的基础知识。一、基本概念：程序、进程、线程、并发、并行注1：一个Java应用程序java.exe，其实至少有三个线程：main()主线程，gc()垃圾回收线程，异常处理线程。当然如果发生异常，会影响主线程。注2：Java中的线程分为两类：一种是守护线程，一种是用户线程。它们在几乎...
复制链接

扫一扫

专栏目录