Java高级编程之多线程

最新推荐文章于 2024-07-22 14:15:06 发布
最新推荐文章于 2024-07-22 14:15:06 发布
阅读量39 收藏
点赞数
分类专栏： javaSE 文章标签： java 开发语言 jvm
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_52365243/article/details/128580864
版权

1.程序、进程、线程的理解

        程序：是为完成特定任务，用某种语言编写的一组指令的集合，即一段静态的代码，静态对象(个人理解:程序是一段代码的集合，程序是“死”的，因为它并没有被加载到内存中)

        进程：是程序的一次执行过程，或是正在运行的一个程序，是一个动态的过程，有它自身的产生、存在、消亡过程-----生命周期(个人理解:被加载到内存中的程序成为了进程，即运行中的程序)

        线程：进程可进一步细化为线程，是一个程序的一条内部执行路径(个人理解:一个进程中可以有一个或多个线程，其代表不同的功能)

           

2.并行与并发

        并行：多个cpu同时执行多个任务，如不同的人做不同的事(错误理解:并行是针对单核而言(即一个cpu)，他会给人一种假象--让你认为它会同时执行多个线程，实际上对于并行而言，cpu会给他们分配时间片，时间片一到就要切换到下一个线程)

        并发：一个cpu(采用时间片)同时执行多个任务。如秒杀、多个人做同一件事(错误理解:并发是针对多核而言(即多个cpu)，不同的cpu同时执行不同的线程即为并发)

3.创建多线程的两种方式

        3.1 继承Thread类

package com.atguigu.java;



class MyThread extends Thread{
    @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) {
        MyThread myThread = new MyThread();
        myThread.start();
        MyThread myThread1 = new MyThread();
        myThread1.start();

        for (int i = 0; i < 100; i++) {
            if (i % 2 != 0) {
                System.out.println(Thread.currentThread().getName()+ i);

            }
        }
        System.out.println("main线程输出");
    }
}

        注意:

                我们启动一个线程必须调用start方法而不能用继承类的对象调用run方法

                如果再启动一个线程，必须再创建该继承类的对象，然后调用start方法 

        详细步骤：

                        1.继承Thread类

                        2.重写run方法

                        3.创建该实现类的对象

                        4.调用start方法

                start方法说明：一经调用start方法就意味着两件事--1.启动了该线程  2.调用了该线程中的run方法 

        3.2 实现Runnable接口

package com.atguigu.java;
// 1.采用同步方法解决线程安全的问题
class  Window2 implements Runnable{
    private int ticket = 100;

    @Override
    public void run() {
        while (true){

                show();

            }


    }
    public synchronized void show(){


        if(ticket > 0){
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+"正在售卖:"+ticket+"票");
            ticket--;
        }

    }
}



public class WindowTest1 {
    public static void main(String[] args) {
        Window2 window = new Window2();
        Thread thread = new Thread(window);
        Thread thread1 = new Thread(window);
        Thread thread2 = new Thread(window);
        thread.start();
        thread1.start();
        thread2.start();



    }
}

        详细步骤：

                        1.创建实现Runnable接口的实现类

                        2.重写Runnable中的run方法

                        3.创建该实现类的对象

                        4.创建Thread类的对象，并将实现类的对象作为参数传递到Thread类构造器中

                        5.调用start方法

               两种实现方式的对比：优先选用实现Runnable接口的方式

                                                        1.实现的方式没有单继承的局限性

                                                        2.实现的方式更适合用来处理数据共享的问题

                                       

        

4.Thread类的常用方法

package com.atguigu.java;

class MyThread2 extends Thread{
    @Override
    public void run() {
        for(int i = 0;i < 100;i++){
            if(i % 2 == 0) {
//                try {
//                    sleep(10);
//                } catch (InterruptedException e) {
//                    e.printStackTrace();
//                }
                System.out.println(Thread.currentThread().getName() + ":" + i);

            }


        }
    }
}


public class ThreadTest1 {
    public static void main(String[] args) {
        MyThread2 myThread2 = new MyThread2();
        myThread2.setName("分线程");
        myThread2.setPriority(Thread.MAX_PRIORITY);
        myThread2.start();
        Thread.currentThread().setName("主线程");
        Thread.currentThread().setPriority(Thread.MIN_PRIORITY);
        for(int i = 0;i < 100;i++){
            if(i % 2 != 0)
            System.out.println(Thread.currentThread().getName()+":"+i);
            

        }

    }




}

        

5.Thread的生命周期

        

 

6.线程的同步机制

        同步代码块：

package com.atguigu.java;
// 1.使用同步代码块解决线程安全的问题
// 需要注意的问题：多个线程要共用同一把锁，任何一个类都可以用来创建一把锁
class  Window implements Runnable{
    private int ticket = 100;
    Object object = new Object();
    @Override
    public void run() {
        while (true){
          synchronized(object){

              if(ticket > 0){
                  try {
                      Thread.sleep(100);
                  } catch (InterruptedException e) {
                      e.printStackTrace();
                  }
                  System.out.println(Thread.currentThread().getName()+"正在售卖:"+ticket+"票");
                  ticket--;
              }
              else {
                  break;
              }
          }

        }
    }
}



public class WindowTest {
    public static void main(String[] args) {
        Window window = new Window();
        Thread thread = new Thread(window);
        Thread thread1 = new Thread(window);
        Thread thread2 = new Thread(window);
        thread.start();
        thread1.start();
        thread2.start();



    }
}

                注意：在使用同步代码块时需要注意同步监视器和共享变量

                        同步监视器：形象的来说，它就是一把锁，这把锁可以是任何一个类的对象，多个线程要共用这把锁，不能每个线程都有属于自己的一把锁，否则仍然会导致线程安全问题。

                        共享变量：多个线程都可以访问的变量称为共享变量

        同步方法：

package com.atguigu.java;
// 1.采用同步方法解决线程安全的问题
class  Window2 implements Runnable{
    private int ticket = 100;

    @Override
    public void run() {
        while (true){

                show();

            }


    }
    public synchronized void show(){


        if(ticket > 0){
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+"正在售卖:"+ticket+"票");
            ticket--;
        }

    }
}



public class WindowTest1 {
    public static void main(String[] args) {
        Window2 window = new Window2();
        Thread thread = new Thread(window);
        Thread thread1 = new Thread(window);
        Thread thread2 = new Thread(window);
        thread.start();
        thread1.start();
        thread2.start();



    }
}

        

        Lock类：

package com.atguigu.java;

import java.util.concurrent.locks.ReentrantLock;

// 1.使用同步代码块解决线程安全的问题
// 需要注意的问题：多个线程要共用同一把锁，任何一个类都可以用来创建一把锁
class  Window4 implements Runnable{
    private int ticket = 100;
    ReentrantLock reentrantLock = new ReentrantLock();

    @Override
    public void run() {
        while (true){

                reentrantLock.lock();
            try {
                if(ticket > 0){
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName()+"正在售卖:"+ticket+"票");
                    ticket--;
                }
                else {
                    break;
                }
            } finally {
                reentrantLock.unlock();
            }



        }
    }
}



public class LockTest1 {
    public static void main(String[] args) {
        Window4 window = new Window4();
        Thread thread = new Thread(window);
        Thread thread1 = new Thread(window);
        Thread thread2 = new Thread(window);
        thread.start();
        thread1.start();
        thread2.start();



    }
}

        同步机制的优点：可以解决线程不安全的问题

                             缺点：每次执行就相当于单线程执行的过程，效率低下 

                

7.线程通信

        需要用到的三个方法：wait()、notify()、notifyAll()

package com.atguigu.java;

class  Communication implements Runnable{
    private int number = 1;

    @Override
    public void run() {
       while (true){
           synchronized (this){
               notify();
               if(number <= 100){
                   System.out.println(Thread.currentThread().getName()+":输出的数字为:"+number);
                   number++;
               }else {
                   break;
               }
               try {
                   wait();
               } catch (InterruptedException e) {
                   e.printStackTrace();
               }
           }


       }
    }
}


public class  CommunicationTest{
    public static void main(String[] args) {
        Communication communication = new Communication();
        Thread thread = new Thread(communication);
        Thread thread1 = new Thread(communication);
        thread.start();
        thread1.start();

    }


}

        需要注意的是三个方法de调用者要是同一个同步监视器(即同一把锁)否则编译不通过

8.JDK5.0新增线程的创建方式

        实现Callable接口

package com.atguigu.java;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

class MyCallable implements Callable<Integer>{


    @Override
    public Integer 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 CallableTest {
    public static void main(String[] args) {
        MyCallable myCallable = new MyCallable();
        FutureTask<Integer> futureTask = new FutureTask<>(myCallable);
        new Thread(futureTask).start();
        try {
            Integer integer = futureTask.get();
            System.out.println(integer);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }


    }



}

                

        线程池

package com.atguigu.java;


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

class  MyPool 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 ThreadPoolTest {
    public static void main(String[] args) {
        ExecutorService executorService = Executors.newFixedThreadPool(10);
        System.out.println(executorService.getClass());
        ThreadPoolExecutor threadPoolExecutor = (ThreadPoolExecutor)executorService;
        threadPoolExecutor.setCorePoolSize(16);



        MyPool myPool = new MyPool();
        executorService.execute(myPool);
        executorService.shutdown();

    }


}

                继承Thread类，实现Runnable接口，实现Callable接口，线程池这四种方法在开发中一般选用线程池的方法。

        线程池的优点:

                1.提高反应时间

               2. 降低资源消耗

9.关于多线程的几个高频面试题

        sleep和wait方法的异同:

  异：      1.所处的类不同，sleep在Thread类中，而wait在Object中

                2.使用的范围不同，sleep可以在任何地方使用，而wait只能在同步代码块或同步方法中使用

                3.sleep方法使用后，不会释放同步监视器，而wait会释放同步监视器

 同:        都能使当前线程阻塞

        synchronized和lock的异同:

异:        synchronized在执行完相应的同步代码块以后，会自动释放同步监视器，而lock需要手动开启同步(lock)，结束同步时也需要手动结束(unlock)。

同:        都能解决线程安全问题

do_your_best_anyway
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java多线程之高级并发编程的应用场景和实践
MRZHQ的博客
02-20 1275
本节介绍了Java高级并发编程的应用场景和实践，包括并发编程的应用场景、使用线程池、锁和同步器、原子变量和CAS、线程安全的数据结构、避免死锁和活锁、使用volatile关键字、并发工具类和合理设计线程安全的程序等实践方法。volatile关键字可以保证变量的可见性，避免线程安全问题和数据不一致的情况。线程安全的数据结构可以避免线程安全问题和数据不一致的情况。合理设计线程安全的程序可以避免线程安全问题和数据不一致的情况。使用原子变量和CAS可以避免线程安全问题和数据不一致的情况。
java多线程编程之线程的生命周期
09-04
Java多线程编程中，线程的生命周期包括四个主要阶段：新建、运行、阻塞和终止。理解这些状态以及如何通过Thread类中的方法控制它们至关重要。 1. **新建**： 当通过`new Thread()`创建一个新的线程对象时，线程...
Java多线程实战-实现多线程文件下载，支持断点续传、日志记录等功能
热门推荐
qq_35716689的博客
03-10 15万+
本文将介绍如何通过Java来实现一个多线程下载器。作者：牵着猫散步的鼠鼠
Java多线程（超详细！）
一只小菜鸡
05-13 12万+
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 多线程练习
qq_57570052的博客
07-28 2213
1.定时器操作（实现电脑定时关机）。2.每个月的月末(02:00:00)执行一次代码3.模拟售票模拟了多个线程同时售票的场景，保证了并发环境下的票的售卖过程的正确性和一致性。4.用15个线程实现，求123456789之间放+-和为100的表达式（11结果），如果一个线程求出结果， 立即告诉其它停止。
Java中的多线程编程与并发控制
AOMGyz的博客
04-26 1077
随着计算机硬件技术的不断发展，多核处理器已经成为现代计算机系统的标配。在这样的背景下，多线程编程与并发控制成为了Java开发中不可或缺的一部分。多线程编程能够充分利用多核处理器的并行计算能力，提高程序的执行效率；而并发控制则能够确保多个线程在共享资源时的正确性和安全性。本文将深入探讨Java中的多线程编程与并发控制。
头歌Educoder——Java高级特性 - 多线程基础（3）线程同步
赵士杰——成功并非一蹴而就，而是在持之以恒的努力中逐渐实现。
03-24 7750
文章目录第1关：并发编程的三个概念任务描述相关知识1.原子性2.可见性3.有序性编程要求题第2关：使用synchronized关键字同步线程任务描述相关知识并发编程什么时候会出现安全问题如何解决线程安全问题synchronized关键字synchronized代码块编程要求测试说明代码示例第3关：使用线程锁（Lock）实现线程同步任务描述2相关知识Lock接口lock()方法的正确使用编程要求代码示例第4关：使用volatile实现变量的可见性任务描述相关知识什么是 volatile 关键字volatile
EduCoder Java高级特性 - 多线程基础（3）线程同步
知足且上进，温柔而坚定
03-07 1万+
第1关：并发编程的三个概念 第2关：使用synchronized关键字同步线程 第3关：使用线程锁（Lock）实现线程同步，使用sleep（）函数解决了第三关线程随机导致的需要评测多次问题 第3关：使用线程锁（Lock）实现线程同步
java 多线程高级面试_15个顶级Java多线程面试题及答案
weixin_33322743的博客
02-24 1297
多线程和并发的问题是任何java面试中必不可少的一部分。1)现在有三个线程：T1、T2和T3。如何确保T2在T1完成后执行，T3在T2完成后执行？这个线程问题通常在第一阶段或电话面试阶段询问，以确定您是否熟悉“连接”方法。此多线程问题比较简单，可以在联接方法中实现。2)在java锁接口优势比同步块是什么？您需要实现一个高效的高速缓存，允许多个用户读取，但只允许一个用户写入，以保持其完整性。你是如何...
Java多线程编程之Lock用法实例
09-03
// 解锁 } }}在Java多线程编程中，`Lock`接口是Java并发包(`java.util.concurrent.locks`)提供的一个高级锁机制，相较于传统的`synchronized`关键字，`Lock`提供了更细粒度的锁控制和更多的特性。`Lock`接口提供了...
JAVA多线程编程技术PDF
08-28
在Java编程领域，多线程是一项至关重要的技术，它允许程序同时执行多个任务，从而提高系统资源的利用率和程序的响应速度。这份“JAVA多线程编程技术PDF”是学习和掌握这一领域的经典资料，涵盖了多线程的全部知识点...
Java高级架构师并发编程之多线程专题
06-15
本课程为完整Java高级架构师课程体系，目的在于培养企业急需的高级开发者，课程内容包括Java热门...本章节为并发编程之多线程专题内容，通过老师的讲解，你能掌握多线程的知识和应对企业的面试。 Java架构师课程体系
Java并发编程和多线程的区别
10-15
Java并发编程和多线程是两个紧密相关的概念，但它们之间存在着重要的区别。并发编程是一种高级的编程范式，旨在设计能够处理多个任务并行执行的程序，从而提高系统效率和资源利用率。它涵盖了一系列的技术和策略，如...
12. Hibernate 模板设计模式
最新发布
这是一个web全栈开发的博客，取其精华去其糟粕，争取让大家一看就懂，一学就会，一用就成~
07-22 586
如何运用模板设计模式重构 Hibernate 操作流程；持久化对象与序列化接口；OOP中有一个编码原则 ：写仅写一次。翻译过来就是，不要重复，要重用。答案是：使用模板设计模式进一步封装Hibernate的操作。在真实项目中，Hibernate仅仅只是完成项目中的一部分工作，需要和其它，如Spring等框架联合工作，一起承担整体项目的开发。Spring框架中就提供的有Hibernate模板对象。一个常规的、频繁的操作代码中，大部分代码不需要变动，只有小部分代码需要根据需求变动。
Java内存模型
weixin_44267758的博客
07-19 707
此处的变量不是指java编程中的变量，它包括了实例字段，静态字段和构成数值对象的元素，但不包括局部变量和方法参数。JMM规定所有变量都存储在主内存中。每条线程有自己的工作内存，工作内存中保留了该线程使用到变量的主内存的副本。线程对变量的所有操作都必须在工作内存中进行，不能直接读写主内存的变量，不同的线程间也无法直接访问对方工作内存的变量，线程之间的变量值传递需要通过主内存来完成。
Promise 详解（原理篇）
山重水复疑无路，柳暗花明又一村。
07-20 683
Promise 是一种异步编程的解决方案。在异步操作中，callback 会导致回调地狱的问题，Promise 解决了这个问题。一个 Promise对象有以下三种状态:pending：初始状态，既不是成功，也不是失败状态。：意味着操作成功完成。rejected：意味着操作失败。当 new Promise() 被实例化后，即表示 Promise 进入 pending 初始化状态，准备就绪，等待运行。
接口防刷！利用redisson快速实现自定义限流注解
架构师小吴的博客
07-18 1220
如登录接口，当用户使用手机号+验证码登录时，一般我们会生成6位数的随机验证码，并将验证码有效期设置为1-3分钟，如果对登录接口不加以限制，理论上，通过技术手段，快速重试100000次，即可将验证码穷举出来。解决思路：对登录接口加上限流操作，如限制一分钟内最多登录5次，登录次数过多，就返回失败提示，或者将账号锁定一段时间。在日常开发中，一些重要的对外接口，需要加上访问频率限制，以免造成资��损失。ok，通过以上两步，即可完成我们的限流注解了，下面通过一个接口验证下效果。
Java多线程编程实战教程
Java多线程编程指南是一份由Sun Microsystems公司发布的专业文档，专为深入研究Java多线程编程的开发者设计。该文档于2006年10月发布，包含了详细的理论知识和实践指导，适用于理解和掌握Java语言中的并发编程技术。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值