java线程

最新推荐文章于 2024-11-03 11:01:20 发布
最新推荐文章于 2024-11-03 11:01:20 发布
阅读量107 收藏
点赞数
文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_69836134/article/details/128102520
版权

多线程

单任务和多任务

单任务处理：在一个任务没有完成时，不会执行别的任务。

多任务处理：在一个任务没有完成时，同时进行别的任务，多个任务同时执行。

多任务处理分类

基于进程：进程是自包容的应用程序，由操作系统直接管理，直接运行。每个进程一开启，都会消耗内存空间。

基于线程：线程是应用程序中的顺序控制流，一个进程中可以包含很多线程，多个线程共享一个进程的内存空间。

线程

主线程

main方法一个运行，就开启一个主线程，每个进程都有一个主线程

**特点：**1.最先开始

2.最后结束

3.产生其他的子线程

4.子线程结束后，回收子线程占用的资源。

创建子线程

1、继承Thread类，重写run方法
class Thread1 extends Thread{
    @Override
    public void run() {

    }

启动线程

        Thread1 thread1=new Thread1();
        //启动线程
        thread1.start();

调用线程类start()和run()方法的区别：

  • 调用start()，会在主线程之外，开启子线程，多个任务同时执行。
  • 调用run()，是普通方法调用，不会在主线程之外，开启子线程，是单任务处理。
2、实现Runnable接口，实现run方法
class Thread2 implements Runnable {
    @Override
    public void run() {

}

启动线程

       //创建线程对象，传入Runnable实现类对象，线程启动后，会执行Runnable实现类的run()
        Thread thread2 = new Thread(new Thread2());
        thread2.start();
3、实现Callable接口，实现calll方法

继承Thead类，重写run，实现Runnable接口，实现run方法。在线程结束后，都不能那个得到返回值。

实现Callable接口，重写call方法，在线程结束后可以得到返回值。

        //创建FutureTask对象，该类为runnable实现类。
        //传入callable实现类对象，线程启动时，会执行callable实现类的call方法
        FutureTask<Integer> task = new FutureTask<Integer>(new Callable<Integer>() {
            @Override
            public Integer call() throws Exception {
                int sum = 0;
                for (int i = 1; i <= 50; i++) {
                    sum += i;
                }
                return sum;
            }
        });
        //启动线程
        new Thread(task).start();
        try {
            //得到线程执行完毕后的返回值
            Integer sum = task.get();
            System.out.println(sum);
        } catch (Exception e) {
            e.printStackTrace();
        }
4、采用线程池创建线程

应用大量通过new Thead()方法创建执行时间短的线程，较大消耗系统资源并且系统的响应速度变慢。

线程池首先创建一些线程，他们的集合称为线程池。线程池在系统启动时即创建大量空闲的线程，程序将一个任务传给线程池，线程池就会启动一条线程来执行这个任务。执行任务结束以后，该线程并不会死亡，而是再次返回线程池中成为空闲状态，等待执行下一个任务。

线程池的工作机制

1、在线程池的编程模式下，任务是提交給整个线程池，而不是直接提交给某个线程，线程池在拿到任务后，就是内部寻找是否有空闲的线程，如果有，则将任务交给某个空闲的线程。

2、一个线程同时只能执行一个任务，但可以同时向一个线程池提交多个任务。

线程池的种类

1、创建一个可以无限扩大的线程池，适用于负载较轻的场景，执行短期异步任务。

    public static void main(String[] args) {
        //创建无限扩展的线程池
        ExecutorService service = Executors.newCachedThreadPool();
        //向线程池提交任务
        service.execute(new Mythead());
        service.execute(new Mythead());
        //关闭线程池
        service.shutdown();

    }

class Mythead implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            //Thread.currentThread()得到当前线程
            System.out.println(Thread.currentThread() + "   " + i);
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

2、创建一个固定大小的线程池，因为采用无界的阻塞队列，所以实际线程数量永远不会变化，适用于负载较重的场景，对当前线程数量进行限制。

        //创建大小为2的线程池
        ExecutorService service = Executors.newFixedThreadPool(2);
        //向线程池提交任务
        service.execute(new Mythead());
        service.execute(new Mythead());
        service.execute(new Mythead());
        //关闭线程池
        service.shutdown();

开始时，线程池中两个线程交替执行两个任务。第三个任务进行等待。当线程池中其中一个线程任务执行完毕，就执行第三个任务。

3、创建一个单线程的线程池，适用于需要保证顺序执行各种任务。

        //创建单线程线程池
        ExecutorService service = Executors.newSingleThreadExecutor();
        service.execute(new Mythead());
        service.execute(new Mythead());
        service.shutdown();

任务一个一个按顺序执行

线程状态

  • 新建 创建Thread对象
  • 就绪 调用start()方法，启动线程
  • 运行 执行run()方法
  • 死亡 run()执行完毕
  • 睡眠 调用Thread.sleep(30)
  • 等待 调用Object类中的wait()
  • 挂起 调用yield()方法，当前线程让出CPU使用权
  • 阻塞 等待IO事件输入

线程优先级

线程优先级是指，当两个或两个以上的线程都处于就绪状态。优先级高的线程，会优先得到执行。

优先级分为10级，1-10，默认为5，数字越大，优先级越高。

优先级的设置和获取

        Thread thread = new Thread();
        //设置线程的优先级
        thread.setPriority(10);
        //得到线程的优先级
        System.out.println(thread.getPriority());

线程同步

当两个或两个以上的线程，同时访问同一个资源时，为了保证数据的安全，只允许同一事件一个线程进行访问。

线程同步的后果

1、数据安全

2、效率低

死锁

死锁是指在多线程情况下，多个线程同步竞争相互依赖的资源，从而造成多线程无法继续执行的情况。

public class DieLok {
    public static void main(String[] args) {
        LockObj o1 = new LockObj("乔丹");
        LockObj o2 = new LockObj("皮蓬");
        new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized (o1) {
                    try {
                        Thread.sleep(200);
                        o2.speak();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized (o2) {
                    try {
                        Thread.sleep(200);
                        o1.speak();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }).start();
    }
}

class LockObj {
    private String name;

    public LockObj(String name) {
        this.name = name;
    }

    public synchronized void speak() {
        System.out.println("我叫：" + this.name);
    }
}
线程同步的实现
使用synchronized

  • 同步方法

    public synchronized void getMoney() {}

  • 同步块

        public void run() {
        synchronized(one){
            one.display();
        }
    }
使用Lock接口
  • Lock是一个接口，而synchronized是Java内置的语言实现
  • synchronized在发生异常时，会自动释放线程占有的锁，因此不会导致死锁现象发生，而Lock在发生异常时，如果没有主动通过unlock()去释放锁，则很可能造成死锁现象，因此使用lock时需要在finally块中释放锁。
  • Lock可以让等待锁的线程响应中断，而synchronized却不行，使用synchronized时，等待的线程会一直等待下去，不能够相应中断
  • 通过Lock可以知道有没有成功获取锁，而synchronized无法办到
  • Lock可以提高多个线程进行读操作的效率
  1. Lock接口常用方法：lock()方法获取锁时，如果锁已经被其它线程获取，则等待
public class LockTest {
    public static void main(String[] args) {
        LockObject lockObject = new LockObject();
        new Thread(new Runnable() {
            @Override
            public void run() {
                lockObject.speak();
            }
        }).start();

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

class LockObject {
    private Lock lockObject = new ReentrantLock();
    public void speak() {
        //加锁
        lockObject.lock();
        try {
            for (int i = 0; i < 10; i++) {
                System.out.print(i);
                    Thread.sleep(200);
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lockObject.unlock();
        }
    }
}

2.trylock()方法是有返回值的，它表示用来尝试获取锁，如果获取成功，则返回ture，如果获取失败（即锁已被其它线程获取），则返回false，也就是说这个方法无论如何都会立即返回，在拿不到锁时不会一直在那等待。

class LockObject {
    private Lock lockObject = new ReentrantLock();
    public void speak() {
        if (lockObject.tryLock()) {
            try {
                for (int i = 0; i < 10; i++) {
                    System.out.print(i);
                    Thread.sleep(200);
                }
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                lockObject.unlock();
            }
        }else {
            System.out.println("获取锁失败");
        }
    }
}

3.读写锁

  • 当有多个线程读写文件时，读操作和写操作会发生冲突现象，写操作和写操作会发生冲突现象，但是读操作和读操作不会发生冲突现象。
  • 读写锁将对一个资源（比如文件）的访问分成了2个锁，一个读锁和一个写锁
  • 如果多个线程都只是进行读操作，所以当一个线程在进行读操作时，其它线程可以同时进行读操作。申请写操作的线程只能等待。
  • 如果有一个线程已经占用了写锁，则此时其它线程如果申请写锁或者读锁，则申请的线程会一直等待释放写锁。
线程通讯

java使用wait()、notify()和notifyAll()方法，完成线程间的通信。

wait()、notify()和notifyAll()都在Object中定义。都只能在同步方法或同步块中使用。

public class WaitTest {
    public static void main(String[] args) {
        TestObj obj = new TestObj();
        new ObjA(obj).start();
        new ObjB(obj).start();
    }
}

class TestObj {
    public boolean isRun = true;
}


class ObjA extends Thread {
    private TestObj obj;

    public ObjA(TestObj obj) {
        this.obj = obj;

    }

    public void run() {
        while (true) {
            synchronized (obj) {
                if (obj.isRun == true) {
                    System.out.print("A");
                    obj.isRun = false;
                    try {
                        Thread.sleep(200);
                        //唤醒等待线程访问obj对象
                        obj.notify();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                } else {
                    try {
                        //当前线程对obj对象等待
                        obj.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    }
}

class ObjB extends Thread {
    private TestObj obj;

    public ObjB(TestObj obj) {
        this.obj = obj;

    }

    public void run() {
        while (true) {
            synchronized (obj) {
                if (obj.isRun == false) {
                    System.out.print("B");
                    obj.isRun = true;
                    try {
                        Thread.sleep(200);
                        obj.notify();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }else {
                    try {
                        obj.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    }
wait和sleep的区别

wait和sleep都可以让线程暂时停止运行，但是使用时机是不同的。

  1. sleep在Thread类中定义，而wait在Object中定义
  2. wait只能放在同步方法或同步块中，表示针对某个对象进行等待。而sleep可以放在方法中任何位置，表示当前线程休眠。
  3. wait会释放对象锁，而sleep不会
  4. sleep在休眠结束后，自动恢复线程运行。而wait需唤醒才能恢复线程运行。
Volatile

变量定义为volatile之后将具备两种特性：

  • 保证此变量对所有的线程的可见性，当一个线程修改了这个变量的值，volatile保证了新值能立即同步到主内存
  • 禁止指令重排序优化
m0_69836134
关注
java 线程 block_JAVA线程的BLOCK状态实例分析
weixin_32790385的博客
02-16 2851
今天主要介绍一下线程block的状态，从实例来分析线程的block状态。背景先介绍一下线程的所有状态信息NEW: 线程创建之后，但是还没有启动(not yet started)。这时候它的状态就是NEW RUNNABLE: 正在Java虚拟机下跑任务的线程的状态。在RUNNABLE状态下的线程可能会处于等待状态， 因为它正在等待一些系统资源的释放，比如IO BLOCKED: 阻塞状态，等待锁的释放...
java线程执行方法_java线程的常用方法
weixin_42300040的博客
02-20 2110
java线程的常用方法编号方法说明1public void start()使该线程开始执行；Java 虚拟机调用该线程的 run 方法。2public void run()如果该线程是使用独立的 Runnable 运行对象构造的，则调用该 Runnable 对象的 run 方法；否则，该方法不执行任何操作并返回。3public final void setName(String name)改变线程...
Java线程锁
陆卿之的博客
06-28 3925
1. synchronized关键字：使用synchronized关键字可以对代码块或方法进行加锁，确保同一时间只有一个线程可以执行被锁定的代码块或方法。 2. ReentrantLock类：ReentrantLock是Java提供的一个可重入锁，它提供了更灵活的锁定机制，可以实现更复杂的同步需求。 3. ReadWriteLock接口：ReadWriteLock接口提供了读写锁的机制，允许多个线程同时读取共享资源，但只允许一个线程写入共享资源。 4. Condition接口：Condition接口是
Java线程系列详解
wang_yong_hui_1234的博客
04-15 5242
1）volatile本质是在告诉jvm当前变量在寄存器中的值是不确定的，需要从主存中读取，synchronized则是锁定当前变量，只有当前线程可以访问该变量，其他线程被阻塞住。2）volatile仅能使用在变量级别，synchronized则可以使用在变量，方法。3）volatile仅能实现变量的修改可见性，而synchronized则可以保证变量的修改可见性和原子性。4）volatile不会造成线程的阻塞，而synchronized可能会造成线程的阻塞。
Java 线程调度
qq_45437885的博客
03-29 1495
Java 线程调度
Java线程阻塞
qq_43966957的博客
12-06 4922
Java线程阻塞
Java线程安全
qq_40132294的博客
10-10 2万+
前段时间有测试一个后端对账单和话单采集服务,在测试过程中有涉及到数据库读写逻辑和并发的场景,所以结合经验针对系统技术架构设计了部分并发场景结合数据库读写时可能出现的一些问题的用例,也确实出现了一些测试环境容易忽视,线上环境确确实实可能出现的问题,当然最后还是得到了妥善的解决.下面说说后端测试应该考虑的一些线程安全和数据读写方面的问题. 前提:测试环境的架构尽量向线上环境的架构靠拢,比如线上如果采用分布式集群,测试环境如果是单机,那么部分问题自然无法暴露,如果测试环境无足够资源模拟线上的几十台集群环境,那么
Java多线程超详解
热门推荐
weixin_44797490的博客
06-11 14万+
引言 随着计算机的配置越来越高，我们需要将进程进一步优化，细分为线程，充分提高图形化界面的多线程的开发。这就要求对线程的掌握很彻底。 那么话不多说，今天本帅将记录自己线程的学习。 线程的相关API //获取当前线程的名字 Thread.currentThread().getName() 1.start():1.启动当前线程2.调用线程中的run方法 2.run():通常需要重写Thread类中的此...
Java 线程
m0_46698935的博客
04-05 2657
Java 线程 程序：静态代码 安装到硬盘上 进程：运行中的程序 是操作系统分配资源的最小单位 线程：线程是进程（程序）中最小执行单元，是CPU进行调度的最小单位 ​ 一个进程中可以包含多个线程，线程不能脱离进程而存在 ​ 一个线程只能属于一个进程 ​ 例：运行中的 Q Q 进程 ​ 主线程 负责启动程序 例如：Java中的main 启动Java主线程 ​ 一个聊天窗口就是一个线
java 线程的优先级
peinanwei__的博客
05-04 4334
线程优先级 现代操作系统基本采用时分的形式调度运行的线程，操作系统会分出一个个时间片，线程会分配到若干时间片，当线程的时间片用完了就会发生线程调度，并等待着下次分配。线程分配到的时间片多少也就决定了线程使用处理器资源的多少，而线程优先级就是决定线程需要多或者少分配一些处理器资源的线程属性。 在Java线程中，通过一个整型成员变量priority来控制优先级，优先级的范围从1~10，在线程构建的时候可以通过setPriority(int)方法来修改优先级，默认优先级是5，优......
Java 线程状态、线程池
01-20
java 线程状态、线程池 1. java 的线程状态 状态 发生条件 NEW 线程刚刚被创建，没有启动，没有调用start方法 RUNNABLE(可运行) 线程已经在JVM中运行，但是是否运行不确定，看当前线程是否由CPU执行权 ...
ｊａｖａ线程
09-28
程研究了线程的基础知识— 线程是什么、线程为什么有用以及怎么开始编写使用线程的简单 程序。 我们还将研究更复杂的、使用线程的应用程序的基本构件— 如何在线程之间交换数据、如何控制 线程以及线程如何互相通信...
Java线程模型缺陷
01-08
Java 编程语言的线程模型可能是此语言中最薄弱的部分。它完全不适合实际复杂程序的要求，而且也完全不是面向对象的。本文建议对 Java 语言进行重大修改和补充，以解决这些问题。 Java 语言的线程模型是此语言的一个...
java 线程 dump 分析工具 2.3.3
09-11
java 线程Dump 分析工具： Java的TDA线程转储分析器是一个用于分析Sun Java VM生成的线程转储和堆信息的小型Swing GUI(目前用1.4测试)。它从提供的日志文件中解析线程转储和类直方图。它提供关于发现的线程转储的...
HashMap为什么线程不安全？
最新发布
rnnf_yyds的博客
11-03 466
HashMap底层是基于数组 + 链表（在 Java 8 以后，当链表长度超过一定阈值时会转换为红黑树）的数据结构。在多线程环境下，当多个线程同时对HashMap进行put操作时，可下面这种情况：假设两个线程 A 和 B 同时执行put操作，它们计算出的插入位置相同（假设为index线程 A 先获取到了当前index位置的节点，在它还没来得及将新节点插入链表（或树）时，线程 B 也获取到了这个位置的节点。
[自用，更新自day5]瑞吉外卖代码及笔记
lapiii的博客
11-01 963
当使用ThreadLocal维护变量时，ThreadLocal为每个使用该变量的线程提供独立的变量副本，所以每一个线程都可以独立地改变自己的副本，而不会影响其它线程所对应的副本。Mybatis Plus公共字段自动填充，也就是在插入或者更新的时候为指定字段赋予指定的值，使用它的好处就是可以统一对这些字段进行处理，避免了重复代码。因为在分页查询的Dish的records(菜品记录中)，只有这个菜品所属的categoryId，但是我们需要分页的时候展示的是菜品名字。
服务器虚拟化
Hellc007的博客
10-30 1001
服务器虚拟化是一种将物理服务器的计算资源分割为多个独立虚拟环境的技术，通过软件层将底层硬件资源抽象化并在上层构建多个虚拟机（Virtual Machine, VM）。每个虚拟机运行独立的操作系统和应用程序，相互之间不受干扰，具备类似于物理服务器的功能。这种技术使得一台物理服务器能够承担多台虚拟服务器的角色，从而极大地提升了硬件资源的利用率。服务器虚拟化的概念最早可追溯到20世纪60年代IBM大型机时代，当时虚拟化被用来将大型机的资源分配给多个任务，使得企业在有限的资源下能够同时运行多个应用。
JAVA 插入 JSON 对象到 PostgreSQL
qq_52143611的博客
10-30 1028
在现代软件开发中，由于 JSON 数据的轻量和通用性，处理 JSON 数据已经变得无处不在。PostgreSQL凭借其对 JSON 的强大支持，为存储和查询 JSON 数据提供了出色的平台。为了将JSON数据保存到PostgreSQL数据库中，我们可以将JSON数据转换为PostgreSQL的JSONB类型数据，然后将其存储在数据库中。在Java中，我们可以使用JDBC或者基于ORM框架的方式来实现这一功能。
Java线程优先级详解
"Java线程的优先级管理是多线程编程中的一个重要概念，它涉及到线程调度和执行的顺序。在Java中，线程的优先级被用来影响线程被操作系统选择执行的概率，但并不保证高优先级的线程一定会先于低优先级的线程执行。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值