线程（线程基本概念、java实现多线程、使用多线程、线程的生命周期、线程同步、线程死锁）

已于 2023-11-28 14:52:44 修改
阅读量99 收藏
点赞数
文章标签： java 线程
于 2023-11-21 20:08:22 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42672802/article/details/134534700
版权

（一）线程基本概念


一、 程序, 进程, 线程的概念


程序: 使用某种语言编写一组指令(代码)的集合,静态的

进程: 运行的程序,表示程序一次完整的执行, 当程序运行完成, 进程也就结束了

个人电脑: CPU 单个, 双核, CPU的时间分片, 抢占式

每个独立执行的程序称为进程

每个进程都有自己独立的内存空间, 进制之间的通信很困难

在操作系统中进程是进行系统资源分配、调度和管理的最小单位，进程在执行过程中拥有独立的内存单元。比如：Windows采用进程作为最小隔离单位，每个进程都有自己的数据段、代码段，并且与别的进程没有任何关系。因此进程间进行信息交互比较麻烦

线程: 一个进程中,可以同时有多条执行链路, 这些执行链路称为线程, 线程是CPU的调度与分配最小单位, 同一个进程多个线程共享这个进程的内存资源: JVM内存模型

二、进程与线程区别:

进程包含线程, 一个进程包含多个线程, 一个进程最小必须包含一个线程(主线程,main线程), 运行main()方法的时候, 创建了一个main线程

一个进程死亡了, 这个进程中所有的线程死亡

线程销毁，进程未必会关闭

并行: 多CPU执行各种不同任务,

并发: 一个CPU执行不同的任务(多个线程)

多线程速度快吗? 看CPU的核数,个数

三、多线程

多线程是指一个进程在执行过程中可以产生多个线程，这些线程可以同时存在、同时运行，形成多条执行线

（二）java实现多线程


在jdk.1.5之前: 创建线程的方式: 两种:

  • 继承Thread类
  • 实现Runnable接口

在JDK1.5之后: 多加了两种:

  • 实现 Callable接口
  • 线程池

第一种方式: 继承Thread

  1. 编写一个类继承Thread,该类是线程类

  2. 重写run(), 编写该线程需要完成的任务

  3. 创建线程类对象

  4. 调用start()方法,启动线程

/**
 * 实现线程的第一种方式:
 * 继承Thread
 */
public class MyThread1 extends Thread{
​
    //private static Object o = new Object();
    public MyThread1(String name) {
        super(name);
    }
​
    //重写run()方法
    @Override
    public void run() {
        //线程完成的功能
        for (int i = 1; i <=10 ; i++) {
            //得到当前正在运行的线程
           //Thread.currentThread()
            //getName() 得到线程的名字
            System.out.println(Thread.currentThread().getName()+":输出"+i);
        }
    }
}

 注意事项:

  1. 线程启动,一定是调用start() , 不是调用run(), 如果直接调用run() ,只是方法的调用,没有创建线程
  2. 一个线程一旦启动,就不能重复启动

第二种方式: 实现Runnable接口

启动线程: 都必须借助Thread的start()

Runnable实现类: 就是一个线程的任务类

继承Thread与Runnable接口的区别:

  1. 继承Thread类, 这个线程类就不能再继承其他类, 实现Runnable接口, 可以再继承其他类
  2. 实现Runnable接口, 可以让多个线程共享这个Runnable的实现类对象
  3. 继承Thread类,启动简单, 实现Runnable接口, 必须依赖Thread类的start()方法

推荐 实现Runnable接口

/**
 * 线程的第二种实现方式: 实现Runnable接口
 */
public class MyRunnable implements  Runnable {
    @Override
    public void run(){
        //线程需要完成的任务
        for (int i = 1; i <=10 ; i++) {
     System.out.println(Thread.currentThread().getName()+":输出"+i);
        }
    }
}

实际开发中使用(推荐)

new Thread(new Runnable() {
        @Override
        public void run() { 
        }
    }).start();

 如果需要返回的线程

Thread t1 = new Thread(()->{
            //操作的业务逻辑
        });
    t1.start();
  //  t1.join();

 t1.join()方法会使所有线程都暂停并等待t1的执行完毕后再执行,其实就是阻塞main主线程继续执行后续的代码

join之所以可以实现线程等待是因为调用wait方法。

join源码中，只会调用wait方法，并没有在结束时调用notify，这是因为线程在die的时候会自动调用自身的notifyAll方法，来释放所有因为该锁陷入等待的资源和锁。

 第三种方式: 实现Callable接口

  1. 第一步编写一个类实现Callable接口,重写call()方法
  2. 启动线程
  3. 创建Callable接口实现类对象
  4. 创建一个FutureTask对象, 传递Callable接口实现类对象, FutureTask异步得到Callable执行结果, 提供get() FutureTask 实现Future接口( get()) 实现Runnable接口
  5. 创建一个Thread对象, 把FutureTask对象传递给Thread, 调用start()启动线程
/**
 * 线程的第三种实现方式:
 *   实现Callable接口
 */
public class MyCallable implements Callable<String> {
    @Override
    public String call() throws Exception {
        //线程睡眠 单位: 毫秒
        Thread.sleep(10000);                   System.out.println(Thread.currentThread().getName()
        +"执行完成");
        return "callable";
    }
}

 第四种方式: 使用线程池创建

1.FixedThreadPool：固定大小的线程池。
2.CachedThreadPool：缓存线程池。该线程池创建的线程数量不固定，当有新任务需要执行时，会创建新的线程来执行任务，如果有线程处于空闲状态，会优先使用空闲线程。适用于执行时间短的任务，如处理HTTP请求等。
3.SingleThreadExecutor：单线程线程池。该线程池只创建一个线程来执行任务，
4.ScheduledThreadPool：定时任务线程池。该线程池可以定时执行任务，可以设置任务执行的时间、执行周期等。适用于需要定时执行任务的场景，如定时备份数据等。

1、使用newCachedThreadPool

newCachedThreadPool创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。

这种类型的线程池特点是：

  • 工作线程的创建数量几乎没有限制(其实也有限制的,数目为Interger. MAX_VALUE), 这样可灵活的往线程池中添加线程。

  • 如果长时间没有往线程池中提交任务，即如果工作线程空闲了指定的时间(默认为1分钟)，则该工作线程将自动终止。终止后，如果你又提交了新的任务，则线程池重新创建一个工作线程。

  • 在使用CachedThreadPool时，一定要注意控制任务的数量，否则，由于大量线程同时运行，很有会造成系统瘫痪。

示例代码如下：

package test;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
   public class ThreadPoolExecutorTest {
   public static void main(String[] args) {
   ExecutorService cachedThreadPool = Executors.newCachedThreadPool();
  for (int i = 0; i < 10; i++) {
   final int index = i;
    try {
    Thread.sleep(index * 1000);
    } catch (InterruptedException e) {
     e.printStackTrace();
    }
    cachedThreadPool.execute(new Runnable() {
     public void run() {
      System.out.println(index);
     }
    });
   }
  }
 }

 2、使用newFixedThreadPool

创建一个指定工作线程数量的线程池。每当提交一个任务就创建一个工作线程，如果工作线程数量达到线程池初始的最大数，则将提交的任务存入到池队列中。

FixedThreadPool是一个典型且优秀的线程池，它具有线程池提高程序效率和节省创建线程时所耗的开销的优点。但是，在线程池空闲时，即线程池中没有可运行任务时，它不会释放工作线程，还会占用一定的系统资源。

示例代码如下：

package test;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
 public class ThreadPoolExecutorTest {
  public static void main(String[] args) {
   ExecutorService cachedThreadPool = Executors.newCachedThreadPool();
   for (int i = 0; i < 10; i++) {
    final int index = i;
    try {
     Thread.sleep(index * 1000);
    } catch (InterruptedException e) {
     e.printStackTrace();
    }
    cachedThreadPool.execute(new Runnable() {
     public void run() {
      System.out.println(index);
     }
    });
   }
  }
 }

3、使用newSingleThreadExecutor

创建一个单线程化的Executor，即只创建唯一的工作者线程来执行任务，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO,优先级)执行。如果这个线程异常结束，会有另一个取代它，保证顺序执行。单工作线程最大的特点是可保证顺序地执行各个任务，并且在任意给定的时间不会有多个线程是活动的。

示例代码如下：

package test;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class ThreadPoolExecutorTest {
 public static void main(String[] args) {
  ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor();
  for (int i = 0; i < 10; i++) {
   final int index = i;
   singleThreadExecutor.execute(new Runnable() {
    public void run() {
     try {
      System.out.println(index);
      Thread.sleep(2000);
     } catch (InterruptedException e) {
      e.printStackTrace();
     }
    }
   });
  }
 }
}

4、使用newScheduledThreadPool

创建一个定长的线程池，而且支持定时的以及周期性的任务执行，支持定时及周期性任务执行。

延迟3秒执行，延迟执行示例代码如下：

package test;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
public class ThreadPoolExecutorTest {
 public static void main(String[] args) {
  ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(5);
  scheduledThreadPool.schedule(new Runnable() {
   public void run() {
    System.out.println("delay 3 seconds");
   }
  }, 3, TimeUnit.SECONDS);
 }
}

表示延迟1秒后每3秒执行一次，定期执行示例代码如下：

package test;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
public class ThreadPoolExecutorTest {
 public static void main(String[] args) {
  ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(5);
  scheduledThreadPool.scheduleAtFixedRate(new Runnable() {
   public void run() {
    System.out.println("delay 1 seconds, and excute every 3 seconds");
   }
  }, 1, 3, TimeUnit.SECONDS);
 }
}

（三）使用多线程

一、启动线程

1.实现线程的第一种方式:*继承Thread

抢占式执行，谁抢到就是谁的，main函数最先执行（多数情况下）

//启动线程
        //创建线程对象
        MyThread1 t1 =new MyThread1("t1");
        MyThread1 t2 =new MyThread1("t2");
        MyThread1 t3 =new MyThread1("t3");
        //调用start()启动线程, 线程与其他线程抢占cpu资源, 谁抢到,执行谁的run()中的代码
        t1.start();
        t1.start();
        t2.start();
        t3.start();
​
        System.out.println("main线程执行完成...");

2.线程的第二种实现方式: 实现Runnable接口

public static void main(String[] args) {        
//创建任务对象        
MyRunnable task = new MyRunnable();        
//创建线程: Thread        
Thread t1 = new Thread(task, "t1");       
Thread t2 = new Thread(task, "t2");        
//启动线程        
t1.start();        
t2.start();    
}

3.线程的第三种实现方式:实现Callable接口

get(); //阻塞的 main最后执行

MyCallable callable = new MyCallable();
        //再次封装 FutureTask
        FutureTask<String> task = new FutureTask<>(callable);
 
        Thread t1 = new Thread(task, "t1");
        //启动线程
        t1.start();
 
        //获取结果
       // String rs = task.get(); //阻塞的,  是main线程在执行
 
        //设置一个超时时间, 一旦到达超时时间, 停止执行,抛一个异常
        //String rs = task.get(1, TimeUnit.SECONDS);
 
        //取消执行
        task.cancel(true);
        //System.out.println(rs);
        System.out.println("main线程执行完成!!");

二,线程的生命周期

新生状态：调用start()方法之前都处于出生状态

就绪状态：调用start()方法后处于就绪状态（又称为可执行状态）

运行状态：得到系统资源后处于运行状态

阻塞状态：如果一个线程在运行状态下发出输入/输出请求，该线程将进入阻塞状态，在其等待输入输出结束时线程进入了就绪状态。

线程阻塞:

死亡状态：当线程run()方法执行完毕时线程进入死亡状态。

  1. 同步阻塞
  2. sleep() Thread的方法 时间到自动醒,释放cpu资源,不释放锁, join() 阻塞
  3. yield() 礼让, 释放cpu资源, 与其他线程抢CPU资源
  4. wait() 等待: Object类中的方法, 一定等待唤醒(notify() notifyAll()), 释放cpu资源,释放锁资源, 线程通信
  5. suspend（）和resume()，由jdk1.0提供，jdk1.2之后就被放弃了，它也是让线程暂停，但是它不释放资源,导致死锁出现

t1.yield(); //礼让
Thread.sleep(1000);
thread4.join();
//等方法会让线程进入阻塞状态 

三,线程同步

同步方法

在方法上添加一个synchronized修饰符, 往对象上加锁

非静态同步方法:锁加在 this(对象)

静态同步方法:锁加在类.class(对象)

锁的释放: 当把同步方法执行完之后,马上释放锁

同步方法: 锁住的代码范围整个方法, 锁的控制粒度太宽

public 返回值类型 方法名(){
  //...
  synchronized(锁对象){
      //锁住的代码
  }
  //...
}

四,线程死锁

多个线程,相互之间需要对方的锁, 但是又不释放自己的锁,造成程序卡住, 这些线程都在等待,等待对方的锁,

死锁形成的原因: 互斥锁,排他锁

1> 互斥使用，即当资源被一个线程使用(占有)时，别的线程不能使用

2> 不可抢占，资源请求者不能强制从资源占有者手中夺取资源，资源只能由资源占有者主动释放。

3> 请求和保持，即当资源请求者在请求其他的资源的同时保持对原有资源的占用。

4> 循环等待，即存在一个等待队列：P1占有P2的资源，P2占有P3的资源，P3占有P1的资源。这样就形成了一个等待环路

形成死锁的这4个条件缺一不可, 避免死锁: 打破4个条件 的一个就可以

项目一定避免出现死锁:

解决死锁:

使用完某个锁,马上释放

多个线程获取锁的顺序是一致, A线程获取锁: a-->b-->c

B线获取锁: a-->b-->v

模拟死锁:

A线程 先获取objA锁, 再获取objB锁, 在获取objB锁时,不释放objA锁

B线程 先获取objB锁, 再获取objA锁, 在获取objA锁时,不释放objB锁

（四）统计线程运行时间

1,java 统计线程运行时间

public class MyThread extends Thread {
    public void run() {
        // 线程相关的任务代码
        for (int i = 0; i < 1000000; i++) {
            // 模拟线程运行的任务
        }
    }

    public static void main(String[] args) {
        // 创建线程
        MyThread thread = new MyThread();
        // 记录开始时间
        long startTime = System.currentTimeMillis();
        // 执行线程任务
        thread.start();
        // 等待线程执行完成
        thread.join();
        // 记录结束时间
        long endTime = System.currentTimeMillis();
        // 输出线程运行时间
        System.out.println("总耗时::"+(endTime-startTime)/1000+"秒");
    }
}

2,例如:一个任务需要2s执行,现在有十个任务,共需要多久时间?

public static void main(String[] args) throws Exception {
		ExecutorService executor = Executors.newFixedThreadPool(10);
		long startTime = System.currentTimeMillis();
		for (int i = 0; i < 10; i++) {
			executor.submit(new Runnable() {
				@SneakyThrows
				@Override
				public void run() {
					Thread.sleep(2000);
					System.out.println("方法一执行完毕------");
					Thread.sleep(2000);
					System.out.println("方法二执行完毕------");
					Thread.sleep(2000);
					System.out.println("方法三执行完毕------");
				}
			});
		}
		executor.shutdown();
		executor.awaitTermination(Long.MAX_VALUE, TimeUnit.NANOSECONDS);
		long endTime = System.currentTimeMillis();
		// 输出线程运行时间
		System.out.println("总耗时::"+(endTime-startTime)/1000+"秒");
	}

青春～要拼搏
关注
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值