线程

最新推荐文章于 2023-03-05 16:47:01 发布
最新推荐文章于 2023-03-05 16:47:01 发布
阅读量80 收藏
点赞数
文章标签： java 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jeremyl/article/details/111592476
版权

@[TOC]线程

线程

基本概念：程序、进程、线程

进程：程序的一次执行过程，是正在运行的程序。
线程：进程进一步细化，是一个程序内部的一条执行路径。一个程序可以同时进行多个线程–》多线程。
进程作为资源分配的单位，系统在运行时会为每个进程分配不同的内存区域。
线程作为调度和执行的单位，每个线程拥有独立的执行栈和程序计数器。

一个java应用程序至少有3个线程：main(), gc()垃圾回收线程，异常处理线程。

并行：多个CPU同时执行多个任务。多个人同时做不同的事。
并发：一个CPU同时执行多个任务。秒杀，多个人做同个事。

何时需要多线程？

  1. 程序需要同时执行多个任务。
  2. 程序需要实现一些需要等待的任务时
  3. 需要一些后台运行的程序时

Note 1: 不能通过直接调用run()方法启动线程
Note 2: 不可以让已经start的线程再去执行

线程的创建和使用（重点）

java.lang.Thread类
创建类型的方法：

  1. 继承于Thread类

方法1: 继承于Thread类

  1. 创建一个继承于Thread类的子类
  2. 重写run方法
  3. 创建子类对象
  4. 通过此对象调用start()
note: 测试Thread中的常用方法：
1. start(): 启动当前线程
2. run(): 通常需要重写Thread类中的此方法，将创建线程要执行的操作声明在此方法中。
3. currentThread(): 静态方法，返回执行当前代码的线程
4. getName(): 获取当前线程的名字
5. setName(): 设置线程名字
6. yield(): 释放当前CPU的执行权
7. join(): 在线程a中调用线程b的join方法，此时线程a进入阻塞状态，直到线程b执行完，a阻塞状态才结束。
8. sleep(long militime): 让当前线程睡眠指定的毫秒，在指定时间内处于阻塞状态。
9. isAlive():
线程的优先级

JAVA调度方法：同优先级使用时间片策略，对高优先级使用优先调度的抢占式策略。

线程的优先级：
MAX_PRIORITY: 10
MIN_PRIORITY: 1
NORM_PRIORITY: 5
涉及的方法：
GET_PRIORITY, SET_PRIORITY

说明：高优先级的线程要抢占优先级线程cpu的执行权，但是只是从概率上讲，不是一定高优先级先执行

方法2：实现Runnable接口

  1. 创建一个实现了Runnable接口的类
  2. 实现类去实现Runnable中的抽象方法：RUN()
  3. 创建实现类的对象
  4. 将此对象作为参数传递到Thread类的构造器中，创建Thread类的对象
  5. 通过Thread类的对象调用start（）方法

比较两种方法：
开发中，优先选择实现Runnable接口方法
原因：1. 没有单继承的限制
2. 更适合处理多个线程共享数据的情况。

线程的生命周期

新建–new
就绪–start()，失去CPU执行权或者yield()，sleep()时间到，join结束，获取同步锁，notify()/notifyAll()
运行–run()，获取CPU执行权
阻塞–sleep()，join(), 等待同步锁，wait() , suspend()
死亡–stop(), 执行完run()，出现Error/Exception且不处理

线程的同步

解决线程的安全问题

  • 方式一：同步代码块-- synchronized(同步监视器){
  • //需要被同步的代码–操作共享数据的代码
  • }
  • 说明：1. 操作共享数据的代码就是需要同步的代码，比如ticket --不能包含多了也不能少了
  •  2. 同步监视器，即是锁。任何一个类的对象都可以作为锁

  •      要求：多个线程必须要用共同一把锁。

  •  3. 在继承Thread类创建多线程的方式中，慎用this充当同步监视器，考虑使用当前类充当
  • 方式二：同步方法
    1. 同步方法仍然涉及到同步监视器，只是不需我们声明
    1. 非静态同步方法，同步监视器是this
  • 静态方法，同步监视器是当前类本身

死锁：所有线程都处于阻塞，无法继续。

Lock(锁）：控制多线程对共享资源进行访问的工具。java.util.concurrent.locks.Lock接口。ReentranLock类实现了Lock

/**
 *解决线程安全问题的方式三：Lock锁 --JDK5.0 新增
 *
 * 1. 面试题：synchronized和lock异同？
 * 相同：都能解决线程安全问题
 * 不同：synchronized机制在执行完相应同步代码以后自动释放同步监视器
 *      Lock需要手动启动同步，同时结束同步也需要手动实现
 *
 * 2. 面试题：如何解决线程安全问题，几种方式
 *
 * @create 2020-12-25 下午3:27
 */
class Window implements Runnable{
    private int ticket=100;
    //1. 实例化ReentranlLock
    private ReentrantLock lock=new ReentrantLock(true);

    @Override
    public void run() {
        while (true){
            try {
                //2. 调用lock()
                lock.lock();

                if (ticket>0){

                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }

                    System.out.println(Thread.currentThread().getName()+": 售票，票号："+ticket);
                    ticket--;
                }else
                    break;
            }finally {
                // 3. 调用解锁的方法
                lock.unlock();
            }

        }
    }
}

public class LockTest {
    public static void main(String[] args) {
        Window w=new Window();

        Thread t1=new Thread(w);
        Thread t2=new Thread(w);
        Thread t3=new Thread(w);

        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");

        t1.start();
        t2.start();
        t3.start();

    }
}

线程的通信

  • 涉及三个方法：
  • wait(): 一旦执行，当前线程进入阻塞状态，并释放同步监视器。
  • notify(): 一旦执行，会唤醒被wait的优先级最高的线程
  • notifyAll(): 唤醒所有被wait的线程
  • note:
    1. 三个方法只能在同步代码块或者同步方法中
    1. 三个方法当中的调用者只能是同步代码块/方法中的同步监视器，否则出异常
    1. 三个方法是定义在java.lang.Object当中的

面试题：sleep方法和wait方法异同

  1. 相同：一旦执行都能使当前线程进入阻塞状态
  2. 不同：1）两个方法声明位置不同，Thread类中声明sleep(), Object类中声明wait()；2）调用要求不同，sleep没要求，wait必须在同步代码块/方法中。3）关于是否释放同步监视器，sleep不会释放，wait会

例题：生产者


/**
 * 线程通信的应用：生产者/消费者问题
 *
 * 生产者将产品交给店员，而消费者从店员处取走产品，
 * 店员一次只能持有固定数量的产品，如果生产者试图生产更多产品，店员会叫停
 * 如果店中有空位放产品了再通知生产者继续生产。
 * 如果店中没有产品，店员会告诉消费者等一下，如果店中有产品了再通知消费者来取走
 *
 * 分析：
 * 1. 多线程问题，生产者线程，消费者线程
 * 2. 有共享数据的问题。店员或者说产品
 * 3. 如何解决线程安全问题？同步机制，有三种方法
 * 4. 是否涉及线程的通信
 *
 */
class Clerk{

    private int productCount=0;

    public synchronized void productProduct() {
        if (productCount<20){
            productCount++;
            System.out.println(Thread.currentThread().getName()+": 开始生产第"+(productCount)+"个产品");
            notify();
        }else {
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public synchronized void consumeProduct() {
        if (productCount>0){
            System.out.println(Thread.currentThread().getName()+"：开始消费第"+productCount+"个产品");
            productCount--;
            notify();
        }else {
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

class Producer extends Thread{
    private Clerk clerk;

    public Producer(Clerk clerk) {
        this.clerk = clerk;
    }

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+":开始生产产品...");

        while (true){
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            
            clerk.productProduct();
        }
    }
}

class Consumer extends Thread{
    private Clerk clerk;

    public Consumer(Clerk clerk) {
        this.clerk = clerk;
    }
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+":开始消费产品...");

        while (true){
            try {
                Thread.sleep(20);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            clerk.consumeProduct();
        }
    }
}


public class ProductTest {
    public static void main(String[] args) {
        Clerk clerk=new Clerk();

        Producer p1=new Producer(clerk);
        p1.setName("生产者1");

        Consumer c1=new Consumer(clerk);
        c1.setName("消费者1");

        p1.start();
        c1.start();
    }

}

JDK5.0新增线程创建方式

新增方式一：实现Callable接口
比runnable更强大，相比run()方法，可以有返回值。可以抛出异常。支持泛型返回值。需要借助FutrunTask类，比如获取返回结果。

**
 * 创建线程方式三：实现Callable接口  ---JDK5.0
 *
 * 问题：如何理解实现Callable接口比实现Runnable接口更强大？ 有返回值，可以抛出异常
 *
 *
 * @create 2020-12-31 下午3:00
 */
//1. 创建一个实现Callable的实现类
class NumThread implements Callable{
    //2. 实现call方法，将此线程需要执行的操作声明在call（）声明中
    @Override
    public Object call() throws Exception {
        int sum=0;
        for (int i = 0; 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接口实现类对象传递到FutrueTask构造器中，创建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();
        }

方式二：使用线程池
提前创建好多个线程，放入线程池中，使用时直接获取，使用完放回池中。
好处：
提高响应速度；降低资源消耗，便于线程管理

package java2;

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

/**
 * 创建线程的方式四：使用线程池
 *
 * corePoolSize: 核心池的大小
 * maximumPoolSize: 最大线程数
 * keepAliveTime: 线程没有任务时最多保持多长时间后会终止
 *
 * @author Hongsen
 * @create 2020-12-31 下午3:46
 */
class numThread 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 numThread1 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);

        // 设置线程池的属性
        

        // 2. 执行指定线程的操作，需要提供实现Runnable接口或者callable接口实现类的对象
        service.execute(new numThread()); // 适合适用于Runnable
        service.execute(new numThread1()); // 适合适用于Runnable

//        service.submit(); // 适合适用于Callable

        // 关闭连接池
        service.shutdown();
    }
}
Jeremy202109
关注
通过Stack Overflow线程栈溢出的问题实例，详解C++程序线程栈溢出的诸多细节
dvlinker的技术专栏
08-04 1万+
通过Stack Overflow线程栈溢出的问题实例，详解C++程序线程栈溢出的诸多细节
关于线程池的使用的一些总结
IT学习小镇
06-14 195
JDK1.5之后提供了一个工厂类用于创建线程池，这个工厂类即是Executors类，它提供一个静态方法用于创建线程池。 static ExecutorService newFixedThreadPool（int nThreads） 该静态方法返回一个ExecutorServie接口的实现类对象，当然，我们可以使用ExecutorService接收（面向接口编程）。 这个接口的实现类对象提供了获取线程并调用start（），执行线程任务的方法。 submit（Runnable task）提交一个Runnabl
对Redis是单线程的理解
DDDDeng_的博客
08-03 293
前言 当面试官问你Redis是单线程还是多线程？你肯定会说：单线程！然后他就会问：单线程为啥还这么快？你就会说出这几条原因： 1、Redis是基于内存的，内存的读写速度非常快，从内存中拿数据比从磁盘上更快。 2、Redis是基于I/O多路复用（非阻塞IO），可以摆脱多线程上下文切换消耗的影响， 你如果真这么说 那她可能也许大概不会太满意 个人理解 redis分客户端和服务端，一次完整的redis请求事件有多个阶段: 1、客户端到服务器的网络连接 2、redis读写事件发生 3、redis服务端的数据处理（单
Java自学基础 多线程
real_rookie的博客
11-05 906
Java多线程前言一、基本概念：程序、进程、线程使用多线程的优点何时需要多线程二、线程的创建和使用线程的创建和启动Thread类API中创建线程的两种方式继承方式和实现方式的联系与区别Thread类的有关方法线程的优先级三、线程的生命周期四、线程的同步Synchronized的使用方法同步机制中的锁同步的范围释放锁的操作不会释放锁的操作单例设计模式之懒汉式(线程安全)线程的死锁问题Lock(锁)synchronized 与 Lock 的对比总结 前言 一、基本概念：程序、进程、线程 程序(progra
java多线程基础（实现多线程的方式，获取与修改线程名的方法）
qq_45476949的博客
03-01 461
1、多线程的并发和并行 并发：在同一时刻，有多个指令在***单个CPU***上***交替***执行； 并行：在同一时刻，有多个指令在多个CPU上同时执行； 2、进程与线程的区别 进程：操作系统中正在执行的一个***应用程序*** 线程：应用程序中做的事情，比如：360软件中的杀毒、扫描木马、清理垃圾 3、多线程的实现方案***（3种）*** 3.1 继承Thread类 定义一个MyThread类继承Thread类； 在Thread中重写run方法（重写run，是因为run方法是用来封装被线程执行的代码）；
多线程 线程池
just_learing的博客
03-24 850
多线程 线程池
QT中利用TCP协议实现了一个多线程的文件互传系统
06-09
在QT框架下，利用TCP协议实现一个多线程的文件互传系统是一项常见的任务，它涉及到网络编程、多线程处理以及文件操作等多个方面。本文将深入探讨这些关键知识点。 首先，TCP（Transmission Control Protocol）是一...
java多线程导出excel（千万级别）优化
12-05
Java多线程导出Excel是处理大数据量时的一种高效策略，尤其在面对千万级别的数据时。传统的Apache POI库在处理大规模数据时可能会遇到栈溢出（StackOverflowError）和内存溢出（OutOfMemoryError）等问题，因为这些...
Linux 多线程原理深剖
qq_61500888的博客
12-24 4万+
带你一命通关 Linux 多线程原理 三十分钟手撕底层内涵
线程 —— 通过 Callable 对象创建线程
李威威的博客
07-24 2635
通过 Callable 对象创建线程。 通过 Callable 创建线程与 Runnable 不同的是：Callable 的 call 方法可以有返回值，而且这个方法可以声明抛出异常。/** * Created by liwei on 16/7/19. * Callable : 是指带泛型的接口 * 这里指定的泛型其实是 call() 方法的返回值类型 */ public class My
快速掌握并发编程---基础篇
田维常
10-06 247
关注“Java后端技术全栈”回复“面试”获取全套面试资料进程与线程进程进程的本质是一个正在执行的程序，程序运行时系统会创建一个进程，并且给每个进程分配独立的内存地址空间保证每个进程地址不...
HTTPServer线程和进程
tycoon的专栏
10-10 3177
http://pymotwcn.readthedocs.org/en/latest/documents/BaseHTTPServer.html   线程和进程¶ HTTPServer是SocketServer.TCPServer的一个简单子类. 它不使用多线程或多进程来处理请求. 要增加多线程和多进程, 可以使用SocketServer中的合适的混用类来创建一个新的类. from
java设置线程池中线程的名字
热门推荐
赶路人儿
03-23 5万+
项目中使用ThreadPoolExecutor进行多线程开发。使用起来很方便，但是当用jstack查看堆栈信息或者Jprofiler调试性能的时候，看到的线程都是pool-1-thread-1\2\3\4之类的。如果一个系统中用到了多个线程池，就无法区分哪个线程造成的系统问题。所以每次都需要点 Thread Dumps 去查看线程执行的具体的代码与堆栈信息，推测是哪个地方出的问题。 于是
多线程实现的三种方法、线程名称的获取
最新发布
changan
03-05 926
多线程实现的三种方法、线程名称的获取
基于callable创建线程
yanghw117的博客
07-28 518
基于callbale创建线程，可以获取线程返回值。实际开发中使用FutureTask结合Callable实现多线程并发调用。在调用futreTask的get（）方法时该方法为阻塞方法，实际开发中可设置超时时间，超过超时时间会抛出异常进行相应业务提示。 import java.util.concurrent.Callable; import java.util.concurrent.Future...
使用callable方式创建线程
qq_41206954的博客
07-12 1356
记录平常一些小事
java输出excel 异常处理_java使用 poi导出Excel 2003异常
weixin_39906358的博客
02-27 278
/***@Title: exportExcelFile@Description: TODO(直接导出数据源)@param @paramrequest@param @paramresponse@param @paramdataFile 设定文件@returnvoid 返回类型@throws*/public static voidexportExcelFile(HttpServletRequest r...
Callable实现多线程
Cruise的博客
06-08 217
class Race implements Callable&lt;Integer&gt;{ private int step=0; private String name; private long time; private boolean flag=true; Race(String name,long ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值