【JavaSE-04】：多线程基础

最新推荐文章于 2024-03-22 17:30:00 发布

Camille丶

最新推荐文章于 2024-03-22 17:30:00 发布

阅读量113

点赞数

分类专栏： JavaSE 文章标签： java

本文链接：https://blog.csdn.net/m0_49167443/article/details/118159600

版权

JavaSE 专栏收录该内容

15 篇文章 0 订阅

订阅专栏

【JavaSE-04】：多线程基础

1、程序、进程、线程的基本概念

程序(program)是为完成特定任务、用某种语言编写的一组指令的集合，被存储在磁盘或其他数据存储设备中。即指一段静态的代码，静态对象。
进程(process)是程序的一次执行过程，或是正在运行的一个程序，是系统运行程序的基本单元。是一个动态的过程：有它自身的产生、存在和消亡的过程。——生命周期
- 程序是静态的，进程是动态的
- 进程作为资源分配的单位，系统在运行时会为每个进程分配不同的内存区域
线程(thread)，进程可进一步细化为线程，是一个程序内部的一条执行路径。
- 线程作为调度和执行的单位，每个线程拥有独立的运行栈和程序计数器(pc)，线程切换的开销小
- 一个进程中的多个线程共享相同的内存单元/内存地址空间和系统资源

2、并行和并发

并行：多个CPU同时执行多个任务。
并发：一个CPU(采用时间片)同时执行多个任务。

3、创建线程的方式一：继承Thread类

定义子类继承Thread类。
子类中重写Thread类中的run方法。
创建Thread子类对象，即创建了线程对象。
调用线程对象start方法：启动线程，调用run方法
代码示例：

//1.创建一个继承于Thread类的子类
class MyThread extends Thread{
    //2.重写Thread类的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 ThreadTest {
    public static void main(String[] args) {
        //3.创建Thread类的子类的对象
        MyThread t1 = new MyThread();
        //4.通过此对象调用start（）
        t1.start();
        //问题一：我们不能通过直接调用run（）的方式启动线程
//        t1.run();
        //问题二：再启动一个线程，遍历100以内的偶数，不可以还让已经start的线程去执行，会报异常
//        t1.start();

        MyThread t2 = new MyThread();
        t2.start();
     
}

4、创建线程的方式二：实现Runnable接口

定义子类，实现Runnable接口。
子类中重写Runnable接口中的run方法。
通过Thread类含参构造器创建线程对象。
将Runnable接口的子类对象作为实际参数传递给Thread类的构造器中。
调用Thread类的start方法：开启线程，调用Runnable子类接口的run方法

//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();
    }
}

5、继承和实现两种方式的区别

public class Thread extends Object implements Runnable

区别
- 继承Thread：线程代码存放Thread子类run方法中。
- 实现Runnable：线程代码存在接口的子类的run方法。
实现方式的好处
- 避免了单继承的局限性
- 多个线程可以共享同一个接口实现类的对象，非常适合多个相同线程来处理同一份资源
  
  开发中：优先选择实现Runnable接口的方式
原因：
1. 实现的方式没有类的单继承性的局限性
2. 实现的方式更适合来处理多个线程有共享数据的情况。

6、Thread类的有关方法

void start(): 启动线程，并执行对象的run()方法
run(): 通常需要重写Thread类中的此方法，将创建的线程要执行的操作声明在此方法中
String getName(): 返回线程的名称
void setName(String name):设置该线程名称
static Thread currentThread(): 返回当前线程。在Thread子类中就是this，通常用于主线程和Runnable实现类
static void yield()：线程让步，释放当前cpu的执行权
- 暂停当前正在执行的线程，把执行机会让给优先级相同或更高的线程
- 若队列中没有同优先级的线程，忽略此方法
join() ：当某个程序执行流中调用其他线程的 join() 方法时，调用线程将被阻塞，直到 join() 方法加入的 join 线程执行完为止
- 低优先级的线程也可以获得执行
static void sleep(long millis)：(指定时间:毫秒)
- 令当前活动线程在指定时间段内放弃对CPU控制,使其他线程有机会被执行,时间到后重排队。
- 抛出InterruptedException异常
stop(): 已过时。强制线程生命期结束，不推荐使用
boolean isAlive()：返回boolean，判断线程是否还活着

7、线程的优先级

同优先级线程组成先进先出队列（先到先服务），使用时间片策略
对高优先级，使用优先调度的抢占式策略

线程的优先级等级：
- MAX_PRIORITY：10
- MIN _PRIORITY：1
- NORM_PRIORITY：5 -->默认优先级
涉及的方法
getPriority() ：返回线程优先值
setPriority(int newPriority) ：改变线程的优先级

8、线程的生命周期

JDK中用Thread.State类定义了线程的几种状态

新建：当一个Thread类或其子类的对象被声明并创建时，新生的线程对象处于新建状态
就绪：处于新建状态的线程被start()后，将进入线程队列等待CPU时间片，此时它已具备了运行的条件，只是没分配到CPU资源
运行：当就绪的线程被调度并获得CPU资源时,便进入运行状态， run()方法定义了线程的操作和功能
阻塞：在某种特殊情况下，被人为挂起或执行输入输出操作时，让出 CPU 并临时中止自己的执行，进入阻塞状态
死亡：线程完成了它的全部工作或线程被提前强制性地中止或出现异常导致结束

9、同步机制：一、Synchronized的使用

同步代码块：

synchronized (对象){ 
   // 需要被同步的代码； 
   }

synchronized还可以放在方法声明中，表示整个方法为同步方法。例如：

public synchronized void show (String name){ 
    …
}

所有操作共享数据的这些语句都要放在同步范围中;

必须确保使用同一个资源的多个线程共用一把锁。

synchronized的锁是什么？
- 任意对象都可以作为同步锁。所有对象都自动含有单一的锁（监视器）。
- 同步方法的锁：静态方法（类名.class）、非静态方法（this）
- 同步代码块：自己指定，很多时候也是指定为this或类名.class

9、同步机制：二、Lock(锁)

java.util.concurrent.locks.Lock接口是控制多个线程对共享资源进行访问的工具。锁提供了对共享资源的独占访问，每次只能有一个线程对Lock对象加锁，线程开始访问共享资源之前应先获得Lock对象。

ReentrantLock 类实现了 Lock ，它拥有与 synchronized 相同的并发性和内存语义，在实现线程安全的控制中，比较常用的是ReentrantLock，可以显式加锁、释放锁。

class A{
  private final ReentrantLock lock = new ReenTrantLock(); 
  public void m(){ 
        lock.lock(); 
        try{ 
              //保证线程安全的代码; 
        } finally{ 
              lock.unlock();  
        } 
  }
}

10、synchronized 与 Lock 的对比

Lock是显式锁（手动开启和关闭锁），synchronized是隐式锁，出了作用域自动释放
Lock只有代码块锁，synchronized有代码块锁和方法锁
使用Lock锁，JVM将花费较少的时间来调度线程，性能更好。并且具有更好的扩展性（提供更多的子类）

优先使用顺序：
Lock -> 同步代码块（已经进入了方法体，分配了相应资源） -> 同步方法（在方法体之外）

11、线程的通信

wait() 与 notify() 和 notifyAll()
- wait()：令当前线程挂起并放弃CPU、同步资源并等待，使别的线程可访问并修改共享资源，而当前线程排队等候其他线程调用notify()或notifyAll()方法唤醒，唤醒后等待重新获得对监视器的所有权后才能继续执行。
- notify()：唤醒正在排队等待同步资源的线程中优先级最高者结束等待
- notifyAll ()：唤醒正在排队等待资源的所有线程结束等待.
这三个方法只有在synchronized方法或synchronized代码块中才能使用，否则会报 java.lang.IllegalMonitorStateException异常。
因为这三个方法必须有锁对象调用，而任意对象都可以作为synchronized的同步锁，因此这三个方法只能在Object类中声明。

12、 JDK5.0 新增线程创建方式:实现Callable接口

与使用Runnable相比， Callable功能更强大些
- 相比run()方法，可以有返回值
- 方法可以抛出异常
- 支持泛型的返回值
- 需要借助FutureTask类，比如获取返回结果
Future接口
- 可以对具体Runnable、Callable任务的执行结果进行取消、查询是
  否完成、获取结果等。
- FutrueTask是Futrue接口的唯一的实现类
- FutureTask 同时实现了Runnable, Future接口。它既可以作为 Runnable被线程执行，又可以作为Future得到Callable的返回值

Camille丶

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
【JavaSE-04】：多线程基础

【JavaSE-04】：多线程基础1、程序、进程、线程的基本概念程序(program)是为完成特定任务、用某种语言编写的一组指令的集合。即指一段静态的代码，静态对象。进程(process)是程序的一次执行过程，或是正在运行的一个程序。是一个动态的过程：有它自身的产生、存在和消亡的过程。——生命周期程序是静态的，进程是动态的进程作为资源分配的单位，系统在运行时会为每个进程分配不同的内存区域线程(thread)，进程可进一步细化为线程，是一个程序内部的一条执行路径。线程作为调度和执行
复制链接

扫一扫