JavaSe学习笔记（十一.1）（进程与线程，进程的三种创建方式，静态代理模式）

最新推荐文章于 2023-12-19 19:45:44 发布
最新推荐文章于 2023-12-19 19:45:44 发布
阅读量257 收藏
点赞数
分类专栏： JavaSe学习笔记 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_47267252/article/details/115112239
版权
本文详细介绍了Java中创建线程的三种方式：继承Thread类、实现Runnable接口和实现Callable接口。通过示例代码展示了每种方式的使用步骤和区别。强调了线程的并发执行和资源竞争问题，并提到了静态代理模式在多线程中的应用。
摘要由CSDN通过智能技术生成

JavaSe学习笔记（十一.1）（进程与线程）

Process(进程）和Thread(线程)

  • 程序是指令与数据的有序集合，其本身没有任何运行的含义，是一个静态的概念
  • 进程则是执行程序的一次执行过程，是一个动态概念，是系统资源分配的单位
  • 通常在一个进程中 可以包含若干线程，线程是CPU调度和执行的单位

很多多线程是模拟出来的，真正的多线程是指有多个CPU，即多核，如服务器。如果是模拟出来的多线程，，即在一个CPU的情况下，在同一个时间点，cpu只能执行一个代码，因为切换的很快，使用有同时执行的错觉。

相关概念

  • 线程就是独立的执行路径
  • 在程序运行的时候，即使自己没有创建线程，后台也会有多个线程，如主线程(main)，gc线程（垃圾回收）
  • main（）称之为主线程，为系统入口，用于执行整个程序
  • 在一个进程中，如果开辟了多个线程，线程的运行时由调度器安排调度，调度器是与操作系统紧密相关的，先后顺序不能人为干预
  • 对同一份资源操作时，会存在资源抢夺的问题，需要加入并发控制
  • 线程会带来额外开销，如cpu调度时间，并发控制开销
  • 每个线程只能在自己的工作内存交互，内存控制不当会造成数据不一致的后果
  • 线程不一定立即执行，CPU调度安排

进程的三种创建方式

1.Thread class (继承Thread类) ★重点

步骤：
  1. 自定义线程类继承Thread类
  2. 重写run()方法，编写线程执行体
  3. 创建线程对象，调用start()方法启动线程
public class TestThread01 extends Thread {
    @Override
    public void run() {
       //run方法线程体
        for (int i = 0; i < 20; i++) {
            System.out.println("我是run线程体--"+i);
        }
    }
    public static void main(String[] args) {
        TestThread01 testThread01 = new TestThread01();
        testThread01.start();
        // testThread01.run():会先将run方法跑完然后运行主线程
        
        for (int i = 0; i < 200; i++) {
            System.out.println("我是主方法--"+i);
        }
    }
}

若是将 testThread01.start();改为testThread01.run():会先将run方法跑完然后运行主线程
结果：两个线程交替执行，同时执行

  • 线程不一定立即执行，CPU调度安排
    在这里插入图片描述
网图下载实例
package com.yu.demo01;


import org.apache.commons.io.FileUtils;

import java.io.File;
import java.io.IOException;
import java.net.URL;

public class TestThread02 extends Thread {
    private String url;//网图地址
    private String name;//下载后的文件名

    public TestThread02(String url,String name) {
        this.url = url;
        this.name = name;
    }


    @Override
    public void run() {
       //run方法线程体
        WebDownloader webDownloader = new WebDownloader();
        webDownloader.downloader(url,name);
        System.out.println("下载名为"+name+"的文件");
    }

    public static void main(String[] args) {
        TestThread02 t1 = new TestThread02("https://img-blog.csdnimg.cn/20210323154429842.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ3MjY3MjUy,size_16,color_FFFFFF,t_70#pic_center","01图片");
        TestThread02 t2 = new TestThread02("https://img-blog.csdnimg.cn/20210321092643202.png#pic_center","02图片");
        t1.start();
        t2.start();
    }

}
/*下载器*/
class WebDownloader{
    public void downloader(String url,String name){
        try {
            FileUtils.copyURLToFile(new URL(url),new File(name));
        } catch (IOException e) {
            e.printStackTrace();
            System.out.println("IO异常，download出现异常");
        }
    }
}

2.Runnable接口 （实现Runnable接口）★★★重点

步骤：

1.定义MyRunnable类实现Runnable接口
2. 重写run()方法，编写线程执行体
3. 创建线程对象，调用start()方法启动线程

package com.yu.demo01;

public class TestThread03 implements Runnable{
    @Override
    public void run() {
       //run方法线程体
        for (int i = 0; i < 200; i++) {
            System.out.println("我是run线程体--"+i);
        }
    }
    public static void main(String[] args) {
        TestThread03 t3 = new TestThread03();
        new Thread(t3).start();

        for (int i = 0; i < 200; i++) {
            System.out.println("我是主方法--"+i);
        }
    }
}
网图下载实例
package com.yu.demo01;


import org.apache.commons.io.FileUtils;

import java.io.File;
import java.io.IOException;
import java.net.URL;

public class TestThread04 implements Runnable {
    private String url;//网图地址
    private String name;//下载后的文件名

    public TestThread04(String url,String name) {
        this.url = url;
        this.name = name;
    }


    @Override
    public void run() {
       //run方法线程体
        WebDownloader webDownloader = new WebDownloader();
        webDownloader.downloader(url,name);
        System.out.println("下载名为"+name+"的文件");
    }

    public static void main(String[] args) {
        TestThread04 t1 = new TestThread04("https://img-blog.csdnimg.cn/20210323154429842.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ3MjY3MjUy,size_16,color_FFFFFF,t_70#pic_center","01图片");
        TestThread04 t2 = new TestThread04("https://img-blog.csdnimg.cn/20210321092643202.png#pic_center","02图片");
        new Thread(t1).start();
        new Thread(t2).start();
    }

}

/*下载器*/
class WebDownloader{
    public void downloader(String url,String name){
        try {
            FileUtils.copyURLToFile(new URL(url),new File(name));
        } catch (IOException e) {
            e.printStackTrace();
            System.out.println("IO异常，download出现异常");
        }
    }
}

区别

  • 继承Thread类
    • 子类继承Thread类，具有多线程能力
    • 启动线程：子类对象.start()
    • 不建议使用：避免OOP单继承局限性
  • 实现Runnable接口
    • 实现接口Runnable具有多线程能力
    • 启动线程：传入目标对象+Thread对象.start()
    • 推荐使用：避免单继承局限性，灵活方便，方便同一个对象被多个线程使用
      方便同一个对象被多个线程使用示例：购票
package com.yu.demo01;

public class TestThread05 implements Runnable{
    private int ticketNums = 10;
    @Override
    public void run() {
       //run方法线程体
        while (true){
            if (ticketNums <= 0){
                break;
            }
            //模拟延时：200毫秒
            try {
                Thread.sleep(200);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            //Thread.currentThread().getName()返回当前执行的线程名字
            System.out.println(Thread.currentThread().getName()+"-->拿走了第"+ticketNums--+"张票");
        }
    }
    public static void main(String[] args) {
        TestThread05 ticket = new TestThread05();

        new Thread(ticket,"浩渺").start();
        new Thread(ticket,"老王").start();
        new Thread(ticket,"小王").start();
    }
}

运行结果：
在这里插入图片描述
发现问题：多个线程针对同一资源操作，线程不安全，数据紊乱
后文线程同步解决。
多线程龟兔赛跑模拟：

package com.yu.test;

//模拟龟兔赛跑
public class Race implements Runnable{
    private int raceLeath = 110;//跑道长度
    private static String winner;

    @Override
    public void run() {
            if (Thread.currentThread().getName().equals("兔子")) {
                try {
                    Thread.sleep(15);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                for (int i = 0; i <= raceLeath ; i++) {
                    gameOver(i);
                    if(winner != null){
                        break;
                    }else {
                        i = i+2;//兔子每次两步
                        System.out.println(Thread.currentThread().getName() + "跑了" + i + "步");
                    }
                }
            }
            if (Thread.currentThread().getName().equals("乌龟")) {
                for (int i = 0; i <= raceLeath; i++) {
                    gameOver(i);
                    if(winner != null){
                        break;
                    }else{
                        i++;//乌龟每次一步
                        System.out.println(Thread.currentThread().getName() + "跑了" + i + "步");
                    }
                }
            }
    }

    //判断游戏是否结束
    private boolean gameOver(int steps){
        if (winner == null){
            if (steps >= 100){
                winner = Thread.currentThread().getName();
                System.out.println("winner is "+winner);
                return true;
            }
        }

        return false;
    }

    public static void main(String[] args) {
        Race race = new Race();
        new Thread(race,"兔子").start();
        new Thread(race,"乌龟").start();
    }
}

3.Callable接口（实现Callable接口）

步骤
  1. 实现Callable接口，需要返回值类型
  2. 重写call方法,需要抛出异常
  3. 创建目标对象
  4. 创建执行服务
    ExecutorService ser = Executors.newFixedThreadPool(2);
  5. 提交执行
    Future<Boolean> r1 = ser.submit(t1);
    Future<Boolean> r2 = ser.submit(t2);
  6. 获取结果
    boolean rs1 = r1.get();
    boolean rs2 = r2.get();
  7. 关闭服务
    ser.shutdownNow();
网图下载实例
package com.yu.demo01;


import org.apache.commons.io.FileUtils;

import java.io.File;
import java.io.IOException;
import java.net.URL;
import java.util.concurrent.*;

public class TestThread06 implements Callable<Boolean>{
    private String url;//网图地址
    private String name;//下载后的文件名

    public TestThread06(String url, String name) {
        this.url = url;
        this.name = name;
    }

    @Override
    public Boolean call() throws Exception {
        WebDownloader webDownloader = new WebDownloader();
        webDownloader.downloader(url,name);
        System.out.println("下载名为"+name+"的文件");
        return true;
    }

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        TestThread06 t1 = new TestThread06("https://img-blog.csdnimg.cn/20210323154429842.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ3MjY3MjUy,size_16,color_FFFFFF,t_70#pic_center","01图片");
        TestThread06 t2 = new TestThread06("https://img-blog.csdnimg.cn/20210321092643202.png#pic_center","02图片");
        //1.创建执行服务
        ExecutorService ser = Executors.newFixedThreadPool(2);//两个线程池
        //2.提交执行
        Future<Boolean> r1 = ser.submit(t1);
        Future<Boolean> r2 = ser.submit(t2);
        //3.获取结果
        boolean rs1 = r1.get();
        boolean rs2 = r2.get();
        //4.关闭服务
        ser.shutdownNow();
    }

}
//下载器
class WebDownloader{
    public void downloader(String url,String name) {
        try {
            FileUtils.copyURLToFile(new URL(url), new File(name));
        } catch (IOException e) {
            e.printStackTrace();
            System.out.println("IO异常，download出现异常");
        }

    }
}
优点
  1. 可以定义返回值
  2. 可以抛出异常

静态代理模式：多线程的底部实现原理

package com.yu.demo;

public class leisure01 {
    public static void main(String[] args) {
        Yu yu = new Yu(new gameRole());
        yu.dream();
    }

}
interface Game{
    void combat();
    void love();
}
//实际角色
class gameRole implements Game{
    @Override
    public void combat() {
        System.out.println("游戏角色去战斗！待到阴阳逆乱时，我以为血染青天！");
    }

    @Override
    public void love() {
        System.out.println("游戏角色有甜甜的恋爱~！今日何日兮，得与宝宝同舟~^~");
    }
}
//代理对象
class Yu implements Game{
    private Game target;

    public Yu(Game target) {
        this.target = target;
    }

    public void dream(){
        this.before();
        this.combat();
        this.love();
        this.after();
    }
    @Override
    public void combat() {
        this.target.combat();
    }

    private void before() {
        System.out.println("我启动了游戏");
    }

    @Override
    public void love() {
        this.target.love();
    }

    private void after() {
        System.out.println("我穿越成为gameRole！老婆~啊哈哈哈哈");
    }

}

结果：
在这里插入图片描述
优点：

  • 代理类可以做其他被代理类未拥有的方法
  • 被代理类只需专注做自己的事
月色夜雨
关注
专栏目录
【Nginx-反向代理服务器】基础知识（二）之多进程模式
何静媛
08-03 3116
Nginx的多进程模式 nginx在启动后，会有一个master进程和多个worker进程。master进程主要用来管理worker进程，包含：接收来自外界的信号，向各worker进程发送信号，监控worker进程的运行状态，当worker进程退出后(异常情况下)，会自动重新启动新的worker进程。而基本的网络事件，则是放在worker进程中来处理了。多个worker进程之间是对等的，他们同等竞
JavaSE学习笔记8-多线程
aoliaoliaoo的博客
06-07 146
多线程 一、简介 线程（Thread）：是程序执行流的最小单元，是系统独立调度和分配CPU（独立运行）的基本单位。 main()是主线程，是系统入口，用于执行整个程序。 进程（Process）：是资源分配的基本单位。一个进程包括多个线程。 例如、QQ、微信、浏览器 多线程：同一时刻执行多个线程。 例如，用浏览器一边下载，一边听歌 多进程：同时执行多个程序。 例如，同时运行QQ、微信、浏览器 二、线程创建 1、方法—Thread类 自定义线程类，继承Thread类 重写ru
JavaEE之多线程基础（1）：进程、线程初识。创建线程的5种方式
guankunkunwd的博客
10-28 891
????一、认识进程、线程 ????1.1什么是进程 进程process/task.“进程"是计算机完成一个工作的"过程” 设备上一个正在运行的程序，就是一个进程。比如你打开的QQ就是一个进程，正在和别人聊天的微信也是一个进程。进程是系统进行资源分配的基本单位。 当我们打开任务管理器就可以看到，当前操作系统中正在运行的进程。 要想让一个进程真正的运行起来，就需要给这个进程分配一定的系统硬件资源。这些资源都包括： CPU:例如我电脑中任务管理器占用了11%的CPU，QQ占用0.3%。 内存：任务管理器占
java se 进程笔记
山重水复疑无路,柳暗花明又一村
02-05 281
java se 进程笔记 进程：正在进行中的程序 线程：就是进程中一个负责程序执行的控制单元（执行路径） 一个进程中可以多执行路径，称之为多线程。 一个进程中至少有一个线程。 开启多个线程是为了同时运行多部分代码。 每一个线程都有自己运行的内容。这个内容可以称为要执行的任务
Java SE 097 线程与进程
青风百草
08-13 188
Java SE 097线程与进程 1.多线程（Multi-Thread） 2.线程与进程的区别 （1）多个进程的内部数据和状态都是完全独立的，而多线程是共享一块内存空间和一组系统资源，有可能互相影响。 （2）线程本身的数据通常只有寄存器数据，以及一个程序执行时使用的堆栈，所以线程的切换比进程切换的负担要小。 （3）线程与线程之间是共享系统资源的。 3.线程的概念 3.1什么是线程？ （1）线程就是程序中单独顺序的流控制。线程本身不能运行，它只能用于程序中。 3.2什么是多线程? [外链图片转存失败,源
多线程之静态代理模式和lambda表达式
weixin_48121041的博客
03-14 134
静态代理模式 静态代理模式中，真实对象和代理对象都需要一个接口 代理对象要代理真实角色 public class StaticProxy { public static void main(String[] args) { WeddingCompany weddingCompany = new WeddingCompany(new You()); weddingCompany.happymarry(); } } //定义一个接口 interface Ma
JavaSE学习笔记（多线程）
m0_62487484的博客
05-15 205
1.线程相关概念2.线程基本使用创建线程的两种方式多线程案例继承 Thread vs 实现 Runnable 的区别3.线程终止4.线程常用方法5.线程的生命周期6.线程的同步7.线程的锁1.互斥锁 注意事项和细节2.线程的死锁3.释放锁同步方法是非静态的，默认锁对象是this 如果方法是静态的，默认锁对象是 当前类.class 实现互锁的步骤 分析需要上锁的代码 选择同步代码块【推荐】或同步方法 要求多个线程的锁对象为同一个 2.线程的死 多个线程都占用了对方的锁资源，但不肯相让，导致了死锁，在编程中
JavaSE学习笔记 Day21
最新发布
CHiN_951的博客
12-19 503
多线程
JavaSE学习笔记
Simon的博客
05-14 1003
主要是整理的自己学习《Java核心技术》（第一卷）的笔记
javase学习笔记，学习时间一个月，发布笔记进度1/3
m0_60726300的博客
04-10 1908
1. Java基本语法 1.1 语言概述 1.1.1 整体语言概述 1.1.2 Java语言概述 1.1.2.1 基础常识 软件：即一系列按照特定顺序组织的计算机数据和指令集合。分为系统软件和应用软件 系统软件：Windows，mac os，linux，unix，android，ios，… 应用软件：word，ppt，画图板 人机交互方式：图形化界面vs命令行方式 应用程序=算法+数据结构 1.1.2.2 计算机语言的发展迭代史 第一代：机器语言 第二代：汇编语言 第三代：高级语言 面向过程：C，P
Java学习笔记 --- 多线程
乌云的博客
11-18 796
1、线程是由进程创建的，是进程的一个实体2、一个进程可以拥有多个线程1、Java语言中，引入了对象互斥锁的概念，来保证共享数据操作的完整性2、每个对象都对应于一个可称为“互斥锁”的标记，这个标记用来保证在任一时刻，只能有一个线程访问该对象3、关键字 synchronized 来与对象的互斥锁联系。当某个对象用 synchronized 修饰时，表明该对象在任一时刻只能由一个线程访问4、同步的局限性：导致程序的执行效率要降低。
JavaSE笔记
errortwo的博客
01-28 332
Java语言跨平台原理 跨平台 Java程序可以在任意操作系统上运行 跨平台原理 在需要运行Java应用程序的操作系统上,安装一个与操作系统对应的Java虚拟机(JVM Java Virtual Machine)即可. JRE和JDK JRE(Java Runtime Environment) JRE是Java程序的运行环境,包含JVM和运行时所需要的核心类库 我们要运行一个已有的Java程序,那么只需要JRE即可 JDK(Java Development Kit) 是Java程序开发工具包,包含JRE和开
JavaSE技术总结：基础到高级，包括注解、泛型、反射与代理
这份JavaSE笔记涵盖了从基础到高级的多个重要主题，包括JDK环境配置、类加载、流与并发、Java新特性、反射、泛型、类加载器、代理模式和AOP等，是Java学习者宝贵的参考资料。通过深入理解和实践这些知识点，开发者...
AOP概念与运行原理
brickworkers的博客
03-21 8203
AOP指的就是面向切面编程，在实际的开发和工作中很多地方都深有体现，比如权限控制，控制全局状态等。接下来会详细阐述AOP的概念，给出对应的DEMO来深入学习实践，探讨AOP的意义。
JAVASE学习笔记（十三）（jdk新特性（AutoCloseable接口 & Stream流））
qq_47267252的博客
12-17 1615
JavaSe学习笔记（十四）Java7新特性 - `AutoCloseable`1. 概述2. 应用场景示例如何解决改进注意 Java7新特性 - AutoCloseable 1. 概述 JDK在1.7之后出现了自动关闭类的功能，该功能的出现为各种关闭资源提供了相当大的帮助，这里我们谈一谈自动关闭类。 JDK1.7之后出现了一个重要的接口，以及改造了一个重要的方法结构： AutoCloseable自动关闭接口 try(){}–catch{}–finally{} 相应的 一些资源也实现了该接口，如P
JAVASE学习笔记（十六）（Optional的应用）
qq_47267252的博客
01-04 1039
jdk1.8新特性的应用 概述 作用 简化程序逻辑 可以修复程序代码中的逻辑判断的问题 源码分析 通过源码分析 ，可以知道是一个， 2. : 相当于 3. :相当于 4. :相当于 应用 ：和 场景：当用户第一次注册给其设置默认昵称和密码： 总结 和区别 问题： 为什么方法会报 由此我们发现：方法如果传入的对象为null，就直接返回 而源码则是当传值为空的时候，直接给创建一个空对象： 中 ,,的认识 注意： ,,都属于的中间方法。但此处的方法与之前的流中间方法无关
JAVASE学习笔记（十五）（行为参数化 & 策略者模式 &匿名内部类 & Lambda表达式）
qq_47267252的博客
12-28 996
JAVASE学习笔记（十五）问题行为参数化标准建模总结问题匿名内部类匿名内部类简述如何选择匿名内部类或实现类解决需求（==重点==）函数式接口总结Lambda表达式 此文为学相伴项目课程笔记 问题 在实际应用场景中，不管你做什么，怎么优化，用户需求总是在不断变化 那么，在理想状态下，应该把自己的开发的工作量降到最小？ 此外类似的功能还应该很简单，而且易于长期维护 所以要如何做？ 此处我们可以引出行为参数化 行为参数化 行为参数化：就是可以帮助你处理频繁变更的需求的一种软件开发模式。 简单来说，就是准
JAVASE学习笔记（十四）（stream流===＞ 结果映射 & 数据处理 &查找检索 ）
qq_47267252的博客
12-20 633
JAVASE学习笔记（十三.2）map & peek & flatmap（结果映射）场景peek解决：map解决flatMap解决flatMap与map区别flatMap语法：map语法结论flatmap的使用1.合并-并集 & 返回指定列2. 合并-交集-共同好友3. 合并-差集reduce（数据处理）概述语法案例其他的操作maptoInt、maptoDouble、maptoLong查找检索 map & peek & flatmap（结果映射） 场景 场景： 把集
JavaSE学习笔记：核心概念与单例模式解析
"这是一篇关于JavaSE学习的心得体会，作者郑晓辉分享了他在学习Java时的一些思考和理解，涵盖了Java的不同版本、核心概念以及设计模式中的单例模式。同时，他也提到了对象的toString()和equals()方法的特殊性，以及...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

月色夜雨

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值