Java - 多线程技术

最新推荐文章于 2024-05-06 10:37:06 发布

qq_40297248

最新推荐文章于 2024-05-06 10:37:06 发布

阅读量82

点赞数

文章标签： java

本文链接：https://blog.csdn.net/qq_40297248/article/details/113407693

版权

一、多线程技术概括：

线程与进程

进程

是指一个内存中运行的应用程序，每个进程都有一个独立的内存空间线程。比如：在Windows系统中，一个运行的exe就是一个进程。

线程

是进程中的一个执行路径，共享一个内存空间，线程之间可以自由切换，并发执行. 一个进程最少有一个线程。
线程实际上是在进程基础之上的进一步划分，一个进程启动之后，里面的若干执行路径又可以划分成若干个线程

线程调度

分时调度：

所有线程轮流使用 CPU 的使用权，平均分配每个线程占用 CPU 的时间。

抢占式调度

优先让优先级高的线程使用 CPU，如果线程的优先级相同，那么会随机选择一个(线程随机性)，Java使用的为抢占式调度。
CPU使用抢占式调度模式在多个线程间进行着高速的切换。对于CPU的一个核新而言，某个时刻，只能执行一个线程，而CPU的在多个线程间切换速度相对我们的感觉要快，看上去就是在同一时刻运行。其实，多线程程序并不能提高程序的运行速度，但能够提高程序运行效率，让CPU的使用率更高。

同步与异步

同步：线程安全，排队执行，效率低但是安全
异步：线程不安全，同时执行，效率高但是数据不安全

并发与并行

并发：指两个或多个事件在同一时间段内发生。
并行：指两个或多个事件在同一时刻发生（同时发生）。

二、多线程技术

标题创建线程的两种方式

1.继承Thread类，扩展线程。

class DemoThread extends Thread {
    @Override
    public void run() {
        super.run();
    }
}
DemoThread t = new DemoThread();
t.start();

继承Thread类，覆盖run()方法。
创建线程对象并用start()方法启动线程。

2.实现Runnable接口

实现Runnable 与继承 Thread 相比有如下优势：
1.通过创建任务，然后给线程非配的方式来实现的多线程，跟适合多个线程同时执行相同任务的情况。
2.可以避免单继承带来的局限性。
3.任务与线程本身是分离的，提高了程序的健壮性。
4.后续学习的线程池技术，接受Runnable类型的任务，不接受Thread类型的线程。

public class MyRunnable implements Runnable {
    @Override
    public void run() {
        for (int i=0;i<10;i++){
            System.out.println("锄禾日当午"+i);
        }
    }
}

//1.  创建一个任务对象
        MyRunnable mr = new MyRunnable();
        //2.  创建一个线程，并为其分配一个任务
        Thread t = new Thread(mr);
        //3.  执行这个线程。
        t.start();
        for (int a=0;a<10;a++){
            System.out.println("上山打老虎"+a);
        }

设置和获取线程名称：

currentThread() 获取当前线程对象
getName(); 获取当前对象名称
setName(); 设置当前对象名称

public static void main(String[] args) {
    System.out.println((Thread.currentThread().getName()));
    Thread t = new Thread(new MyRunnable());
    new Thread(new MyRunnable(),"哈哈").start();
    new Thread(new MyRunnable()).start();
    new Thread(new MyRunnable()).start();

}

static class MyRunnable implements Runnable{

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName());;
    }
}

线程的休眠 sleep

for (int i=1;i<11;i++){
    System.out.println(i);
    Thread.sleep(1000); //休眠时间为1000毫秒
}

线程阻塞

可以参考：https://blog.csdn.net/Sunshine_2211468152/article/details/87299708

线程的中断

如果线程需要执行一个长时间任务，就可能需要能中断线程。中断线程就是其他线程给该线程发一个信号，该线程收到信号后结束执行run()方法，使得自身线程能立刻结束运行。

re.interrupt（）中断

public static void main(String[] args) {
    Thread t1 = new Thread(new MyRunnable());
    t1.start();
    for (int i=1;i<=5;i++){
        System.out.println(Thread.currentThread().getName()+":"+i);
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    t1.interrupt();  //t1中断
}
static class MyRunnable implements Runnable{
    @Override
    public void run() {
        for (int i=1;i<=10;i++){
            System.out.println(Thread.currentThread().getName()+":"+i);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                System.out.println("发现了中断，我们死亡");
                return;
                //e.printStackTrace();
            }
        }
    }
}

守护线程

线程：分为守护线程和用户线程
用户线程：当一个进程不包括任何的存活的用户线程时，进行结束。
守护线程：守护用户线程的，当最后一个用户线程结束时，所有守护线程自动死亡。
ts.setDaemon(true) 守护线程必须放在线程开始前面

线程安全问题

线程不安全

线程同步：synchronized

1.同步代码块

格式：

synchronized(锁对象){
           }

锁对象：任何对象都可以打上锁的标记。要看同一把锁才可以保证线程安全其中一个线程执行的时候，其他线程不能插足。

2.同步方法

给方法添加synchronized 就可以排队执行
如果不是静态的方法:

锁对象是this
如果是静态的方法：

锁对象就是.class
同步代码块和同步方法是隐式锁

显示锁 Lock 子类 ReentrantLock

Lock l = new ReentrantLock();

l.lock; 锁定锁
l.unlock; 解开锁

显示锁和隐式锁的区别

出身不同：（原始的构成）
synchronized ：Java中的关键字，是由jvm 来维护的。是JVM层面的锁
Lock ：是JDK5以后才出现的具体的类。使用lock是调用对应点API 。是API层面的锁

一句话概述：

可以把`synchronized`理解为官二代或是星二代。从娘胎出来自带光环的。 `lock`就是我们普通努力上进的人。

使用方式不同：
所谓的显示和隐式就是在使用的时候，使用者要不要手动写代码去获取锁和释放锁的操作。
synchronized不需要写其他的代码。是由系统维护的，如果非逻辑问题的话，是不会出现死锁的。
lock 我们使用者是需要手动获取锁的释放锁。如果没有释放锁，就有可能导致出现死锁的现象。
手动获取锁方法： lock.lock（）
释放锁：lock.unlock（） 需要配合try/finally语句来完成。

用生活中的一个case来形容这个不同：

官二代和普通人的你正在进入机关大院的时候待遇。 官二代不需要出示什么证件就可以进入，但是你需要手动出示证件在可以进入。

3.等待是否可中断
synchronized是不可中断的。除非抛出异常或者正常运行完成。

lock可以中断的。中断方式：

调用设置超时方法 tryLock（long timeout，timeUnit unit）
调用lockIntreeuptibly（）放在代码块中，然后调用interrupt（）方法可以中断。

生活中小case来理解这一区别：

 官二代一般不会做饭。都会去餐厅点餐等待着餐厅出餐。普通人的你既可以去餐厅等待，如果等待时间长的话，你就可以回去自己做饭了。

4.加锁的时候是否公平

synchronized ：非公平锁

lock ：两者都是可以的。默认是非公平锁。在其构造方法的时候可以传入Boolean值。

true：公平锁
false：非公平锁

生活中小case来理解这个区别：

官二代一般都不排队，喜欢插队的。普通人的你虽然也喜欢插队。但是如果遇到让排队的情况下，你还是会排队的。

5.锁绑定多个条件来condition

synchronized ：没有。要么随机唤醒一个线程，要么是唤醒所有等待的线程。
lock ：用来实现分组唤醒需要唤醒的线程，可以精确的唤醒，而不是像sync那样，不能精确唤醒线程。
6.从性能比较

synchronized是托管给JVM执行的，低效能的不过现在正在优化。
lock 是Java写的控制锁的代码。性能更高一些。

7.从使用锁的方式比较

公平锁和非公平锁

公平锁：排队进行；
不公平锁：不排队，同时进行，比较乱

线程死锁

一个线程可以获取一个锁后，再继续获取另一个锁。
在获取多个锁的时候，不同线程获取多个不同对象的锁可能导致死锁。
两个线程各自持有不同的锁，然后各自试图获取对方手里的锁，造成了双方无限等待下去，这就是死锁。

多线程通信问题

等待唤醒机制：（wait() \ notify() ）
notifyALL() 方法会唤醒在此对象监视器上等待的所有线程。
wait() 在其他线程调用此对象的notify()方法或者notifyALL方法前，导致当前线程等待。

三、线程池

线程池 Executors

如果并发的线程数量很多，并且每个线程都是执行一个时间很短的任务就结束了，这样频繁创建线程就会大大降低系统的效率，因为频繁创建线程和销毁线程需要时间. 线程池就是一个容纳多个线程的容器，池中的线程可以反复使用，省去了频繁创建线程对象的操作，节省了大量的时间和资源。

线程池的好处

降低资源消耗。
提高响应速度。
提高线程的可管理性。

Java中的四种线程池 . ExecutorService

1. 缓存线程池

/**
  * 缓存线程池.
  * (长度无限制)
  * 执行流程:
  *   1. 判断线程池是否存在空闲线程
  *   2. 存在则使用
  *   3. 不存在,则创建线程 并放入线程池, 然后使用
  */
 ExecutorService service = Executors.newCachedThreadPool();
 //向线程池中 加入 新的任务
 service.execute(new Runnable() {
   @Override
   public void run() {
     System.out.println("线程的名称:"+Thread.currentThread().getName());
   }
 });
 service.execute(new Runnable() {
   @Override
   public void run() {
     System.out.println("线程的名称:"+Thread.currentThread().getName());
   }
 });
 service.execute(new Runnable() {
   @Override
   public void run() {
     System.out.println("线程的名称:"+Thread.currentThread().getName());
   }
 });

2. 定长线程池

/**
  * 定长线程池.
  * (长度是指定的数值)
  * 执行流程:
  *   1. 判断线程池是否存在空闲线程
  *   2. 存在则使用
  *   3. 不存在空闲线程,且线程池未满的情况下,则创建线程 并放入线程池, 然后使用
  *   4. 不存在空闲线程,且线程池已满的情况下,则等待线程池存在空闲线程
  */
 ExecutorService service = Executors.newFixedThreadPool(2);
 service.execute(new Runnable() {
   @Override
   public void run() {
     System.out.println("线程的名称:"+Thread.currentThread().getName());
   }
 });
 service.execute(new Runnable() {
   @Override
   public void run() {
     System.out.println("线程的名称:"+Thread.currentThread().getName());
   }
 });

3. 单线程线程池

效果与定长线程池 创建时传入数值1 效果一致.
 /**
  * 单线程线程池.
  * 执行流程:
  *   1. 判断线程池 的那个线程 是否空闲
  *   2. 空闲则使用
  *   4. 不空闲,则等待 池中的单个线程空闲后 使用
  */
 ExecutorService service = Executors.newSingleThreadExecutor();
 service.execute(new Runnable() {
   @Override
   public void run() {
     System.out.println("线程的名称:"+Thread.currentThread().getName());
   }
 });
 service.execute(new Runnable() {
   @Override
   public void run() {
     System.out.println("线程的名称:"+Thread.currentThread().getName());
   }
 });

4. 周期性任务定长线程池

public static void main(String[] args) {
 /**
  * 周期任务 定长线程池.
  * 执行流程:
  *   1. 判断线程池是否存在空闲线程
  *   2. 存在则使用
  *   3. 不存在空闲线程,且线程池未满的情况下,则创建线程 并放入线程池, 然后使用
  *   4. 不存在空闲线程,且线程池已满的情况下,则等待线程池存在空闲线程
  *
  * 周期性任务执行时:
  *   定时执行, 当某个时机触发时, 自动执行某任务 .
   */
 ScheduledExecutorService service = Executors.newScheduledThreadPool(2);
 /**
  * 定时执行
  * 参数1.  runnable类型的任务
  * 参数2.  时长数字
  * 参数3.  时长数字的单位
  */
 /*service.schedule(new Runnable() {
   @Override
   public void run() {
     System.out.println("俩人相视一笑~ 嘿嘿嘿");
   }
 },5,TimeUnit.SECONDS);
 */
 /**
  * 周期执行
  * 参数1.  runnable类型的任务
  * 参数2.  时长数字(延迟执行的时长)
  * 参数3.  周期时长(每次执行的间隔时间)
  * 参数4.  时长数字的单位
  */
 service.scheduleAtFixedRate(new Runnable() {
   @Override
   public void run() {
     System.out.println("俩人相视一笑~ 嘿嘿嘿");
   }
 },5,2,TimeUnit.SECONDS);
}

更多可以参考：https://www.cnblogs.com/riskyer/p/3263032.html

qq_40297248

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java - 多线程技术

Java - 线程、多线程、线程池总结一、多线程技术概括：线程与进程线程调度同步与异步并发与并行二、多线程技术一、多线程技术概括：线程与进程进程是指一个内存中运行的应用程序，每个进程都有一个独立的内存空间线程。比如：在Windows系统中，一个运行的exe就是一个进程。线程是进程中的一个执行路径，共享一个内存空间，线程之间可以自由切换，并发执行. 一个进程最少有一个线程。线程实际上是在进程基础之上的进一步划分，一个进程启动之后，里面的若干执行路径又可以划分成若干个线程线程调度分时
复制链接

扫一扫