Java高级编程之多线程

最新推荐文章于 2024-08-01 11:42:45 发布
最新推荐文章于 2024-08-01 11:42:45 发布
阅读量121 收藏
点赞数
分类专栏： 大数据之Javase 文章标签： 大数据之java基础总结
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44757575/article/details/99702636
版权

1.程序、进程、线程：

  • 程序：是指为实现一定功能的由计算机语言编写的一组指令的集合，可理解为静态的代码；
  • 进程：可以理解为一个正在执行的程序或程序的一次执行过程，它具有生命周期；进程作为资源分配的单位，运行在系统时会为每个进程分配不同的内存区域；
  • 线程：线程可以理解为进程的进一步细分，一个进程可以有多个线程；（一个 java.exe至少有三个线程：main方法主线程、GC垃圾回收线程、异常处理线程）

2.创建线程

  • 方式①
    继承Thread类重写run方法：
class MyThread1 extends Thread{
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            try {
                //让当前线程休眠10毫秒
                Thread.sleep(10);
            } catch (InterruptedException e) {
                    e.printStackTrace();
            }
            System.out.println(i+"====="+Thread.currentThread().getName());
        }
    }
}

public class ThreadTest {
    public static void main(String[] args){
    	//主方法线程循环打印0-499
    	for (int i = 0; i < 500; i++)   System.out.println(i+"====="+Thread.currentThread().getName()); 
    	//创建自定义线程对象
	MyThread thread = new MyThread()；
	//重新命名自定义线程
	thread.setName("MyThread");
	//设置线程优先级
	thread.setPriority(Thread.MAX_PRIORITY);
	//启动自定义线程
	thread.start();
}
  • 方式②
    实现Runnable接口重写run方法：
class  MyRunnable implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 100; i++)	System.out.println(i+"====="+Thread.currentThread().getName())
    }
}

public class ThreadTest {
    public static void main(String[] args){  
        for (int i = 0; i < 500; i++)   System.out.println(i+"====="+Thread.currentThread().getName()); 
        
        Thread thread1=new Thread(new MyRunnable(),"MyRunnable");
        thread1.setPriority(Thread.MAX_PRIORITY);
        thread1.start();
    }
}
  • 方式③
    实现Callable接口重写call方法：
class MyCallable implements Callable<Integer>{
 
    @Override
    public Integer call() throws Exception { //返回类型为Integer
        Thread.sleep(100);
        int sum = 0;
        for(int i=0;i<100;i++)	sum += i;
        return sum;
    }
}

public class FutureTest {
    public static void main(String[] args) {
        ExecutorService executor = Executors.newCachedThreadPool(); //构造线程池
        MyCallable task = new MyCallable();
        Future<Integer> result = executor.submit(task); //获取任务执行结果
        executor.shutdown();     
        try {
            System.out.println("task运行结果"+result.get());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}
  • tips:
    ①线程在启动【start()】之后会执行继承了Thread的类中的run方法中的代码
    ②实现了Runnable接口意味着该类具有可执行性，但该实现类不是线程类
    ③多个线程同时执行，它们之间是互不干扰的，并且线程的执行具有随机性
    ④线程有十个优先级（1-10）但设置的线程优先级高的不一定会被CPU优先执行
    ⑤继承Thread类和实现Runnable接口两种方式的比较：
    • Thread类实现了Runnable接口（联系）
    • Runnable接口解决了单继承的局限性
    • 当有共享数据时，使用实现方式更好，同时共享数据所在的类可以作为Runnable接口的实现类

3.线程的状态：

  • 创建：new Thread()//创建线程对象，并给线程设置默认名称
  • 就绪：当线程对象调用start()方法时，线程进入就绪状态，该线程状态表示可被执行，并不一定立即被执行；
  • 运行：当CPU调度到某线程时，该线程处于运行状态
  • 阻塞：sleep()、wait()、join()、suspend()【过时】、线程同步锁【当线程进入阻塞状态时，会暂时让出CPU资源】
  • 死亡：正常执行完run()/main()方法、线程对象调用stop()、Error/Exception未被处理；
  • 线程状态图：

4.线程的同步机制

  • 前提：如果我们创建的多线程中有存在着共享数据，那么就有可能出现出现线程安全问题：当其中一个线程操作共享数据还未结束时，另一个线程参与进来，导致共享数据的操作出现问题。
  • 解决方法：要求一个线程完成对共享资源的操作之后，其他的线程才能操作共享资源

    • 方式一：同步代码块：
      synchronized( 同步监视器 ){ //操作共享数据的代码 }

      • 注：
        ①同步监视器：俗称锁，任何一个类的对象都可以才充当锁。要想保证线程的安全，必须要 求所有的线程共用同一把锁！
        ②使用实现Runnable接口的方式创建多线程的话，同步代码块中的锁，可以考虑是【this】。如 果使用继承Thread类的方式，不用this，可以考虑【类名.class】
        ③共享数据：多个线程需要共同操作的变量。 明确哪部分是操作共享数据的代码。

    • 方式二：同步方法：
      将操作共享数据的方法声明为synchronized。
      比如：public synchronized void show(){ //操作共享数据的代码}
      注：①.对于非静态的方法而言，使用同步的话，默认锁为：this。如果使用在继承的方式实现多线程 的话，慎用this！
      ②静态的方法如果使用同步，默认的锁为：当前类本身。

    • tips:

      • 释放锁：wait()
      • 不释放锁：sleep()、yield()
      • 死锁：不同的线程分别占用对方的同步资源不放弃，都在等对方放弃自己需要的同步资源，这就形 成了死锁（死锁无法解决，只能避免）例：
public class DeadLock {  
    private static String Stephen="Stephen";  
    private static String Curry="Curry";  
    public static void main(String[] args){  
        new DeadLock().deadLock();  
    }   
  private void deadLock(){  
        Thread threadA=new Thread(new Runnable(){  
            @Override  
            public void run(){  
                synchronized(Stephen){  
                    try {  
                        Thread.currentThread().sleep(1000);
                    } catch (InterruptedException e) {   
                        e.printStackTrace();  
                    }  
                    synchronized(Curry){  
                        System.out.println("AB");  
                    }  
                }  
            }  
        }).start(); 
       Thread threadB=new Thread(new Runnable(){  
            @Override  
            public void run(){  
                synchronized(Curry){  
                    try {  
                        Thread.currentThread().sleep(1000);  
                    } catch (InterruptedException e) {   
                        e.printStackTrace();  
                    }  
                    synchronized(Stephen){  
                        System.out.println("BA");  
                    }  
                }  
            }  
        }).start();
    }  
}

5.线程的通信
①两个线程交替打印1-100自然数

public class CommunicationTest {

    public static void main(String[] args) {
        Print print = new Print();
        Thread thread1 = new Thread(print);
        Thread thread2 = new Thread(print);

        thread1.setName("线程1打印：");
        thread1.start();

        thread2.setName("线程2打印：");
        thread2.start();
    }
}

class Print implements Runnable {
    public static int num = 1;

    @Override
    public void run() {
        while (true) {
            synchronized (this) {
                if (num <= 100) {
                    //唤醒另外一个线程
                    this.notify()；            
                    System.out.println(Thread.currentThread().getName()+(num++));

                    try {                       
                        wait(); //该线程释放资源进去阻塞状态
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                } else  break;
            }
        }
    }
}

②生产者与消费者

public class TestProductAndCustomer {
    public static void main(String[] args) {
        Waitter waitter = new Waitter();
        Productor p = new Productor(waitter);
        Customer c1 = new Customer(waitter);
        Customer c2 = new Customer(waitter);

        new Thread(p).start();
        new Thread(c1).start();
        new Thread(c2).start();

    }
}

class Waitter {
    private int produce = 0;

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


    }
    public synchronized void custom() {

        if (produce > 0) {
            System.out.println(Thread.currentThread().getName() +
                    "消费了第" + produce + "个产品");
            produce--;
            notify();
        } else {
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

class Productor implements Runnable {
    private Waitter waitter;

    public Productor(Waitter waitter) {
        this.waitter = waitter;
    }

    @Override
    public void run() {
        while (true) {
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            waitter.produce();
        }
    }
}

class Customer implements Runnable {
    private Waitter waitter;

    public Customer(Waitter waitter) {
        this.waitter = waitter;
    }

    @Override
    public void run() {
        while (true) {
            try {
                Thread.sleep(20);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            waitter.custom();
        }
    }
}

tips：
线程的通信：如下的三个方法必须使用在同步代码块或同步方法中：

  • wait():当在同步中，执行到此方法，则此线程“等待”，直至其他线程执行notify()的方法，将其唤醒，唤醒后继续其wait()后的代码

  • notify()/notifyAll():在同步中，执行到此方法，则唤醒其他的某一个或所有的被wait的线程。

  • 线程安全的懒汉式：

class SingleTon{
    private static SingleTon instance;
    private SingleTon() {}
    public static SingleTon1 getIntance(){
        if (instance==null){
            synchronized (SingleTon1.class){
                if(instance==null)
                    return instance=new SingleTon1();
            }
        }
        return instance;
    }
}
念达
关注
专栏目录
Java高级架构师并发编程之多线程专题
06-15
本课程为完整Java高级架构师课程体系，目的在于培养企业急需的高级开发者，课程内容包括Java热门...本章节为并发编程之多线程专题内容，通过老师的讲解，你能掌握多线程的知识和应对企业的面试。 Java架构师课程体系
Java并发编程和多线程的区别
10-15
Java并发编程和多线程是两个紧密相关的概念，但它们之间存在着重要的区别。并发编程是一种高级的编程范式，旨在设计能够处理多个任务并行执行的程序，从而提高系统效率和资源利用率。它涵盖了一系列的技术和策略，如...
Objective-C高级编程iOS和OS X多线程和内存管理（阅读笔记GCD篇）
硬币2014
09-21 811
1.1什么是GCD Grand Central Dispatch是异步执行任务的技术之一。将应用程序中的线程管理用的代码在系统级中实现。开发者只需要定义想执行的任务并追加到适当的Dispatch Queue中，GCD就能生成必要的线程并计划执行任务，这样就比以前的线程更有效。 例子： dispatch_async(queue, ^{ /* 长时间处理 ...
java高级编程——多线程（一）之实现多线程
晃在云淡风轻
05-29 1696
文章目录线程与进程并行与并发JVM虚拟机是多线程的吗多线程实现继承Thread类实现Runnable接口两种方法的区别与联系利用Callable接口实现多线程 线程与进程 线程和进程一样，都是实现并发的一个基本单位。 线程是依赖进程存在的。先来说进程，进程就是程序的一次动态执行过程。通俗来讲，进程就是正在运行的程序，它是系统进行资源分配和调用的独立单位。每一个进程都有它自己的内存空间和系统资源。 ...
Java高级程序设计作业目录（作业笔记）
杨明金的博客
09-22 3930
持续更新中............. Java高级程序设计笔记 • 【目录】 我的大学笔记>>> 第1章 IO流 >>> 1.1.3 编写Java程序，在电脑硬盘里，查看 f:\text4\name 目录是否存在。 1.2.3编写Java程序，在一个文件夹内，查找占用磁盘空间最大的 jpg 文件，并输出文件大小 1.3.5编写Java程序，在硬盘中选取一个 txt 文件，读取该文档的内容后，追加一段文字“[ 来自新华社 ]”，保存到一个新的 txt...
Java多线程实战-实现多线程文件下载，支持断点续传、日志记录等功能
热门推荐
qq_35716689的博客
03-10 25万+
本文将介绍如何通过Java来实现一个多线程下载器。作者：牵着猫散步的鼠鼠
JAVA并发编程——多线程
L170311的博客
03-21 1168
由于内核线程的支持，每个轻量级进程都成为一个独立的调度单元，即使有一个轻量级进程在系统调用中阻塞了，也不会影响整个进程继续工作，但是轻量级进程具有它的局限性：首先，由于是基于内核线程实现的，所以各种线程操作，如创建、析构及同步，都需要进行系统调用。从广义上来讲，一个线程只要不是内核线程，就可以认为是用户线程（User Thread,UT），因此，从这个定义上来讲，轻量级进程也属于用户线程，但轻量级进程的实现始终是建立在内核之上的，许多操作都要进行系统调用，效率会受到限制。线程的实体包括程序、数据和TCB。
Java零基础之多线程篇：多线程最佳实践
喵手的博客
08-01 1228
在计算机科学领域，多线程是一种重要的编程概念。它允许程序同时执行多个任务，提高了程序的并发性和响应性。对于Java开发者而言，了解和掌握多线程编程是非常重要的一项技能。本文将从零基础开始介绍Java多线程的概念和用法，帮助读者理解多线程的原理和实践技巧。我们将深入探讨多线程的最佳实践，包括源代码解析、应用场景案例、优缺点分析和具体的Java代码测试用例。本文将带领读者逐步学习Java多线程编程的基础知识和高级概念。我们将通过详细的源代码解析和实际应用场景案例，帮助读者理解多线程的内部工作原理和使用技巧。
Java多线程（超详细！）
一只小菜鸡
05-13 13万+
1、什么是进程？什么是线程？ 进程是:一个应用程序（1个进程是一个软件）。 线程是：一个进程中的执行场景/执行单元。 注意：一个进程可以启动多个线程。 eg.对于java程序来说，当在DOS命令窗口中输入： java HelloWorld 回车之后。 会先启动JVM，而JVM就是一个进程。 JVM再启动一个主线程调用main方法。 同时再启动一个垃圾回收线程负责看护，回收垃圾。 最起码，现在的java程序中至少有两个线程并发， 一个是垃圾回收线程，一个是执行main方法的主线程。 3、进程和线程是什么关系？
java多线程（超详细）
zdl66的博客
08-14 10万+
进程就是正在运行中的程序（进程是驻留在内存中的）是系统执行资源分配和调度的独立单位每一进程都有属于自己的存储空间和系统资源注意：进程A和进程B的内存独立不共享。
头歌Educoder——Java高级特性 - 多线程练习题
赵士杰——成功并非一蹴而就，而是在持之以恒的努力中逐渐实现。
03-24 1万+
文章目录第1关：顺序输出任务描述相关知识（略）编程要求测试说明代码示例第2关：售票窗口任务描述相关知识（略）编程要求测试说明代码示例Station.javaTask.java 第1关：顺序输出 任务描述 本关任务：利用多线程相关知识控制三个线程，依照先后顺序顺序输出。 相关知识（略） 编程要求 请仔细阅读右侧代码，在 Begin-End 区域内进行代码补充，使线程依照先后顺序依次输出JavaThread+线程名。 提示：我们知道线程的执行结果是随机的，什么时候执行线程是看哪一个线程抢占到了CPU的资源，现在
java多线程编程之向线程传递数据的三种方法
09-04
在Java多线程编程中，向线程传递数据是一个关键的操作，特别是在异步开发模式下。由于线程的并发执行特性，数据的传递不能像同步编程那样直接通过函数参数和返回值来完成。以下是三种主要的向线程传递数据的方法： ...
基于Java并发编程的多线程同步与锁机制.zip
09-06
本项目旨在深入探讨Java并发编程中的多线程同步与锁机制，涵盖了从基础的线程创建、同步方法到高级的并发工具类如ReentrantLock、ReadWriteLock、Atomic类等的使用。通过一系列的示例代码和详细的文档说明，帮助...
JAVA多线程编程技术PDF
08-28
在Java编程领域，多线程是一项至关重要的技术，它允许程序同时执行多个任务，从而提高系统资源的利用率和程序的响应速度。这份“JAVA多线程编程技术PDF”是学习和掌握这一领域的经典资料，涵盖了多线程的全部知识点...
excore-0.1.1b0-py3-none-any.whl
最新发布
09-27
excore-0.1.1b0-py3-none-any.whl
基于C语言实现的疫情防疫智能小车消毒机器人设计源码
09-27
该项目为基于C语言开发的疫情防疫智能小车消毒机器人开源源码，总文件量为166个，涵盖35个头文件（.h）、35个源文件（.c）、34个数据文件（.d）、10个Makefile文件（.mk）、2个映射文件（.map）、2个C/C++项目文件（.cproject、.project）、1个启动配置文件（.launch）和1个项目文件（.project）。此设计旨在提高室内消毒效率，适用于走廊等外部干扰较少的环境。通过智能小车的应用，实现了安全高效的消毒作业，减少了人力消耗和消毒盲区。机器人可通过红外循迹技术进行自动导航，并配备一键启动功能，进一步解放劳动力，确保消毒工作的稳定性和可靠性。
《open3d+pyqt》open3d窗口显示到qt中
09-27
《open3d+pyqt》open3d窗口显示到qt中
学生选课系统代码系统 Springboot学生选课系统（程序，中文注释）
09-27
学生选课系统-学生选课系统-学生选课系统-学生选课系统-学生选课系统-学生选课系统-学生选课系统-学生选课系统-学生选课系统-学生选课系统-学生选课系统-学生选课系统 1、资源说明：学生选课系统源码，本资源内项目代码都经过测试运行成功，功能ok的情况下才上传的。 2、适用人群：计算机相关专业(如计算计、信息安全、大数据、人工智能、通信、物联网、自动化、电子信息等)在校学生、专业老师或者企业员工等学习者，作为参考资料，进行参考学习使用。 3、资源用途：本资源具有较高的学习借鉴价值，可以作为“参考资料”，注意不是“定制需求”，代码只能作为学习参考，不能完全复制照搬。需要有一定的基础，能够看懂代码，能够自行调试代码，能够自行添加功能修改代码。 4. 最新计算机软件毕业设计选题大全(文章底部有博主联系方式): https://blog.csdn.net/2301_79206800/article/details/135931154 技术栈、环境、工具、软件： ① 系统环境:Windows ② 开发语言：Java ③ 框架：SpringBoot ④ 架构:B/S、MVC ⑤ 开发环境:IDE
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值