JavaSE笔记23：多线程（一）

最新推荐文章于 2023-11-13 01:41:52 发布
最新推荐文章于 2023-11-13 01:41:52 发布
阅读量149 收藏
点赞数
分类专栏： JavaSE java 文章标签： 多线程 java 编程语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qwq_666/article/details/110134001
版权
JavaSE 同时被 2 个专栏收录
28 篇文章 0 订阅
订阅专栏
java
28 篇文章 1 订阅
订阅专栏

多线程（一）

1.线程简介

任务、进程、线程、多线程

多任务，例如：边吃饭边玩手机、边开车边打电话…

进程：在操作系统中运行的程序就是进程，如QQ、播放器、游戏…

线程：例如，播放器可以听见声音，播放的声音就是一个线程

多线程：一个进程可以有多个线程，如视频中同时听声音、看图像、看弹幕…

进程与线程的关系

举个例子：

A：进程 B：进程

​ a1：A的一个线程 b1：B的一个线程

​ a2：A的一个线程 b2：B的一个线程

注意1：

  1. 进程A和进程B的内存独立不共享
  2. java语言中，A的线程和B的线程在堆内存和方法区内存共享，但是栈内存独立，一个线程一个栈

如：XX游戏是一个进程，XX音乐是一个进程，这两个进程是独立的，不共享资源

假设启动10个线程，会有10个栈空间，每个栈和每个栈之间互不干扰，各自执行各自的，这就是多线程并发。

java中之所以有多线程机制，目的就是为了提高程序的处理效率。

在这里插入图片描述

注意2：

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

    例如：T1线程执行T1的，T2线程执行T2的，T1不会影响T2，T2也不会影响T1，这是多线程并发。对于多核的CPU电脑来说，真正的多线程并发是没有问题的，例如4核CPU，表示同一时间点上，可以真正的有4个进程并发执行。对于单核的CUP来说，在某一个时间点上实际上只能处理一件事情，但是由于CPU的处理速度极快，多个线程之间频繁切换，给人的感觉是同时在做。

  2. 在程序运行时，即使没有自己创建线程，后台也会有多个线程，如主线程，gc线程。

package se5.thread;
/*
分析以下程序有几个线程（除垃圾回收线程）
    1个线程，因为程序只有1个栈
    （注意：一个方法并不是一个线程，如果是，那不扯么？！）
 */
public class ThreadTest01 {
    public static void main(String[] args) {
        System.out.println("main begin");
        m1();
        System.out.println("main over");
    }
    private static void m1() {
        System.out.println("m1 begin");
        m2();
        System.out.println("m1 over");
    }
    private static void m2() {
        System.out.println("m2 begin");
        m3();
        System.out.println("m2 over");
    }
    private static void m3() {
        System.out.println("m3 execute!");
    }
}

2.线程创建

三种创建方式：

  1. Thread class ------> 继承Thread类（重点）
  2. Runnable接口 ------> 实现Runnable接口（重点）
  3. Callable接口 ------> 实现Callable接口（目前作为了解）
第一种方式
  1. 自定义线程类继承Thread类
  2. 重写run()方法，编写线程执行体
  3. 创建线程对象，调用start()方法启动线程
//定义线程类
public class MyThread extends Thread{
    public void run(){...}
}
//创建线程对象
MyThread t = new MyThread();
//启动线程
t.start();

package se5.thread;
/*
实现线程的第一种方式：编写一个类直接继承java.lang.Thread，重写run方法
怎么创建线程对象？ new就行了
怎么启动线程？ 调用线程对象的start()方法
 */
public class ThreadTest02 {
    public static void main(String[] args) {
        //这里是main方法，这里的代码属于主线程，在主栈中运行
        //新建一个分支流对象
        MyThread t = new MyThread();
        //启动线程
        //start方法的作用是：启动一个线程分支，在JVM中开辟一个新的栈空间，这段代码任务完成之后瞬间就结束了。
        //这段代码的任务只是为了开辟一个新的栈空间，只有新的栈空间开出来，start方法就结束了，线程就启动成功了。
        //启动成功的线程会自动调用run方法，并且run方法在分支线的栈底部（压栈）
        //run方法在分支栈的栈底部，main方法在主栈的栈底部，run和main是平级的
        t.start();//start方法不结束，是不会往下执行其他代码的
        //t.run();//不会启动线程，不会分配新的分支线（这种方法就是单线程）
        //这里的代码还是运行在主线程中
        for (int i = 0; i < 1000; i++) {
            System.out.println("主线程--->" + i);
        }
        /**
         * 部分输出结果：
         * 分支线程--->172
         * 分支线程--->173
         * 主线程--->19
         * 分支线程--->174
         * 分支线程--->175
         */
    }
}
class MyThread extends Thread{
    @Override
    public void run(){
        //编写程序，这段程序运行在分支线程（分支栈）中
        for (int i = 0; i < 1000; i++){
            System.out.println("分支线程--->"+ i);
        }
    }
}
图片下载例子

注意：此例子下载了commons-io-2.6工具包

package com.thread;

import org.apache.commons.io.FileUtils;

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

//练习Thread，实现多线程同步下载图片
public class TestThread2 extends Thread{

    private String url;//网络图片地址
    private String name;//保存的文件名
    //有参构造方法
    public TestThread2(String url,String name){
        this.url = url;
        this.name = name;
    }
    //下载图片线程的执行体
    @Override
    public void run() {
        WebDownloader webDownloader = new WebDownloader();
        webDownloader.downloader(url,name);
        System.out.println("下载的图片文件名是：" + name);
    }

    public static void main(String[] args) {
        TestThread2 t1 = new TestThread2("http://img1.gamersky.com/upimg/pic/2018/01/18/201801181052241016_small.jpg","南天之怒.jpg");
        TestThread2 t2 = new TestThread2("http://img1.gamersky.com/upimg/pic/2017/06/06/201706061152547794_small.jpg","神拳.jpg");
        TestThread2 t3 = new TestThread2("http://img1.gamersky.com/upimg/pic/2018/01/18/201801181052251036_small.jpg","北辰之威.jpg");
        //启动线程
        t1.start();
        t2.start();
        t3.start();
        /**
         * 本次运行结果：
         * 下载的图片文件名是：北辰之威.jpg
         * 下载的图片文件名是：神拳.jpg
         * 下载的图片文件名是：南天之怒.jpg
         */
    }
}
//下载器
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异常，downloader方法出现问题");
        }
    }
}

在这里插入图片描述

第二种方式
  1. 定义MyRunnable类实现Runnable接口
  2. 实现run()方法，编写线程执行体
  3. 创建线程对象，调用start()方法启动线程
public class MyRunnable implements Runnable{
    public void run(){...}
}
//创建线程对象
Thread t = new Thread(new MyRunnable());
//启动线程
t.start;

package com.thread;
/*
创建线程方式二：实现Runnable接口，重写run()方法，执行线程需要丢入Runnable接口实现类，调用start方法
 */
public class TestThread3 implements Runnable{

    @Override
    public void run() {
        //run方法线程体

        for (int i = 0; i < 1000; i++) {
            System.out.println("卧尼玛--->" + i);
        }
    }

    public static void main(String[] args) {
        //main线程，主线程

        //创建一个线程对象
        TestThread3 testThread3 = new TestThread3();
        //创建线程对象，通过线程对象来开启我们的线程，代理。
        Thread thread = new Thread(testThread3);
        thread.start();
        //以上两句可简写为：new Thread(testThread3).start();

        for (int i = 0; i < 1000; i++) {
            System.out.println("卧你妈--->" + i);
        }
        /**
         * 本次运行结果：
         * 卧尼玛--->768
         * 卧尼玛--->769
         * 卧你妈--->721
         * 卧你妈--->722
         */
    }
}

图片下载例子也可改为实现Runnable接口的方式

图片下载例子
package com.thread;

import org.apache.commons.io.FileUtils;

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

/*
练习Thread，实现多线程同步下载图片
 */
public class TestThread2 implements Runnable{

    private String url;//网络图片地址
    private String name;//保存的文件名
    //有参构造方法
    public TestThread2(String url,String name){
        this.url = url;
        this.name = name;
    }
    //下载图片线程的执行体
    @Override
    public void run() {
        WebDownloader webDownloader = new WebDownloader();
        webDownloader.downloader(url,name);
        System.out.println("下载的图片文件名是：" + name);
    }

    public static void main(String[] args) {
        TestThread2 t1 = new TestThread2("http://img1.gamersky.com/upimg/pic/2018/01/18/201801181052241016_small.jpg","南天之怒.jpg");
        TestThread2 t2 = new TestThread2("http://img1.gamersky.com/upimg/pic/2017/06/06/201706061152547794_small.jpg","神拳.jpg");
        TestThread2 t3 = new TestThread2("http://img1.gamersky.com/upimg/pic/2018/01/18/201801181052251036_small.jpg","北辰之威.jpg");
/*
        Thread thread1 = new Thread(t1);
        Thread thread2 = new Thread(t2);
        Thread thread3 = new Thread(t3);

        thread1.start();
        thread2.start();   
        thread3.start();
        可简写，如下
 */
        new Thread(t1).start();
        new Thread(t2).start();
        new Thread(t3).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异常，downloader方法出现问题");
        }
    }
}

在这里插入图片描述

还有使用匿名内部类的方式，了解下
package se5.thread;
/*
采用匿名内部类方式
 */
public class ThreadTest04 {
    public static void main(String[] args) {
        //采用匿名内部类方式创建线程对象
        Thread t = new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 100; i++) {
                    System.out.println("t线程--->" + i);
                }
            }
        });
        //启动线程
        t.start();
        for (int i = 0; i < 100; i++) {
            System.out.println("main线程--->" + i);
        }
    }
}
小结

继承Thread类

  1. 子类继承Thread类具备多线程能力
  2. 启动线程：子类对象.strat()
  3. 不建议使用：避免OOP单继承局限性

实现Runnable接口

  1. 实现接口Runnable具有多线程能力
  2. 启动线程：传入目标对象 + Thread对象.start()
  3. 推荐使用：避免单继承局限性，灵活方便，方便同一个对象被多个线程使用
第三种方式，Callable（JDK8新特性，了解即可）

这种方式实现的线程可以获取线程的返回值。之前的两种方式无法获取线程的返回值，因为run方法返回void。

package se5.thread;

import java.util.concurrent.Callable;
import java.util.concurrent.FutureTask;//属于java的并发包，老JDK中没有这个包
/*
实现Callable接口
 */
public class ThreadTest15 {
    public static void main(String[] args) throws Exception {

        //第一步：创建一个未来任务类对象，这里采用匿名内部类的方式
        //参数非常重要，需要给一个Callable接口实现类对象
        FutureTask task = new FutureTask(new Callable() {
            @Override
            public Object call() throws Exception {//call()方法相当于run方法，只不过这个有返回值
                //线程执行一个任务，执行之后可能会有一个执行结果
                //模拟执行
                System.out.println("call method begin");
                Thread.sleep(1000 * 10);
                System.out.println("call method end!");
                int a = 100;
                int b = 200;
                return a + b;//自动装箱(300结果变成Interger)
            }
        });
        //创建线程对象
        Thread t = new Thread(task);
        //启动线程
        t.start();

        //这里是main方法，主线程中
        //在主线程中如何获取t线程的返回结果？
        //get方法的执行会导致当前线程阻塞
        Object obj = task.get();
        System.out.println("线程执行结果:" + obj);

        //main方法这里的程序要执行必须等待get方法的结束
        //而get方法可能需要很久，因为get方法是为了拿另一个线程的执行结果
        //另一个线程执行是需要时间的
        System.out.println("Hello World!");
        /**
         * 运行结果：
         * call method begin
         * call method end!
         * 线程执行结果:300
         * Hello World!
         */
    }
}

优点：可以获取到线程的执行结果

缺点：效率比较低，在获取t线程结果的时候，当前线程受阻塞

例子：
package com.thread2;

import org.apache.commons.io.FileUtils;

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

/*
练习Thread，实现多线程同步下载图片
 */
public class TestCallable implements Callable {

    private String url;//网络图片地址
    private String name;//保存的文件名
    //有参构造方法
    public TestCallable(String url,String name){
        this.url = url;
        this.name = name;
    }
    //下载图片线程的执行体
    @Override
    public Boolean call() {
        WebDownloader webDownloader = new WebDownloader();
        webDownloader.downloader(url, name);
        System.out.println("下载的图片文件名是：" + name);
        return true;
    }

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        TestCallable t1 = new TestCallable("https://img1.gamersky.com/upimg/pic/2018/10/14/201810141820249816_small.jpg","KDA.jpg");
        TestCallable t2 = new TestCallable("https://img1.gamersky.com/upimg/pic/2018/07/02/201807021201141166_small.jpg","图2.jpg");
        TestCallable t3 = new TestCallable("https://img1.gamersky.com/upimg/pic/2018/09/27/201809271122535513_small.jpg","图3.jpg");

        //创建执行服务：ExecutorService ser = Executor.newFixedThreadPool(int i);
        ExecutorService ser = Executors.newFixedThreadPool(3);
        //提交执行
        Future<Boolean> r1 = ser.submit(t1);
        Future<Boolean> r2 = ser.submit(t2);
        Future<Boolean> r3 = ser.submit(t3);
        //获取结果：
        boolean rs1 = r1.get();
        boolean rs2 = r2.get();
        boolean rs3 = r3.get();
        //关闭服务
        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异常，downloader方法出现问题");
        }
    }
}

在这里插入图片描述

最爱琴女E
关注
专栏目录
JavaSE学习笔记：多线程
超级无敌小胖头
09-01 195
一、线程实现方式 1.1并发与并行 并发：多个事件在同一个时间段内发生(交替执行) 并行：多个事件在同一个时刻发生（同时执行） 1.2线程和进程 1.2.1进程 所有的应用程序都只能在内存中执行，所以在内存中执行的应用程序就是一个进程。 1.2.2线程 线程是进程中的一个执行单元，负责当前进程中程序的执行，一个进程中至少有一个线程。一个进程中是可以有多个线程的，这个应用程序也可以称之为...
Javase进阶1：多线程
weixin_43498449的博客
05-14 260
目录 0.学习目标 1. 笔记 2. 练习 0.学习目标 1、整理多线程题目 （1）wait和sleep区别 （2）线程的状态有哪些 （3）在同步代码块或者同步方法中，什么情况下会释放锁 2、编写多线程代码 /** * 创建两个线程 * 创建一个初始 变量 值 包子状态为false * 实现一个线程吃包子，另外一个线程做包子 * 交替，进行10次 */ 3、编写泛型方法，实现两个数相加，限定参数只能是数字 1. 笔记 1、线程间通信 （1）创建线程因为操作系统进行...
JavaSE基础24笔记多线程
欢迎大家互相交流分享
01-28 169
24.01_多线程(多线程的引入)(了解) 1.什么是线程 线程是程序执行的一条路径, 一个进程中可以包含多条线程 多线程并发执行可以提高程序的效率, 可以同时完成多项工作 2.多线程的应用场景 红蜘蛛同时共享屏幕给多个电脑 迅雷开启多条线程一起下载 QQ同时和多个人一起视频 服务器同时处理多个客户端请求 24.02_多线程(多线程并行和并发的区别)(了解) 并行就是两个任务同时...
（Java学习笔记）JavaSE 多线程
陌然白（小白）的博客
04-06 961
多线程 文章目录多线程1、 基本概念 程序、进程、线程2、线程的创建和使用（重点）2.1、Thread类2.2、Thread类中有关的基本方法2.3、线程调度 时间片式 抢占式等2.4、JDK5.0之前创建线程的两种方式2.41方式一：继承Thread类2.42方式二：实现Runnable接口2.43、比较创建线程的两种方式2.5、jDK5.0新增创建线程的两种方式2.51、方式一...
javaSE学习笔记（八）多线程
最新发布
给自己的程序生涯留下一点痕迹
11-13 229
线程是程序执行的一条路径，一个进程中可以包含多条线程多线程并发执行可以提高程序的效率，可以同时完成多项工作线程池里的每一个线程执行完任务后，并不会销毁，而是再次回到线程池中成为空闲状态，等待下一个对象来使用JDK5以后不再需要手动编写线程池，提供了内置线程池Executors 的 4 个功能线程池虽然方便，但现在已经不建议使用了，而是建议直接通过使用 ThreadPoolExecutor 的方式，这样的处理方式让写的同学更加明确线程池的运行规则，规避资源耗尽的风险。
JavaSE笔记7.1-多线程-概述
qq_38503984的博客
02-04 1211
一. 进程和线程 进程：是一个正在执行中的程序。 每一个进程执行都有一个执行的顺序，该顺序就是一个执行路径，或者叫一个控制单元。 线程：就是进程中的一个独立的控制单元。 线程在控制着进程的执行。 一个进程中至少有一个线程。 二. Java的运行进程 javac.exe：Java的编译进程 java.exe：Java的运行进程 Java JVM启动的时候会有一个进程java.exe 该进程中至少有...
JavaSE基础25笔记多线程及GUI
欢迎大家互相交流分享
01-29 144
25.01_多线程(单例设计模式)(掌握) 单例设计模式：保证类在内存中只有一个对象。 如何保证类在内存中只有一个对象呢？ (1)控制类的创建，不让其他类来创建本类的对象。private (2)在本类中定义一个本类的对象。Singleton s; (3)提供公共的访问方式。 public static Singleton getInstance(){return s} 单例写法两...
JavaSE笔记7.8-多线程-停止线程
qq_38503984的博客
02-22 171
stop( )已经过时 1. 如何停止线程 让run方法结束 因为开启多线程运行，运行代码通常都是循环结构， 所以只要控制住循环结构，就可以让run方法结束，也就是线程结束。 package Test1; class StopThread implements Runnable{ //标记flag用来控制循环的停止 private boolean flag=true; pu...
JavaSE学习笔记(四)：多线程
weixin_46476301的博客
03-27 612
目录 背景 以单核CPU为例，只使用单个线程先后完成多个任务(调用多个方法），肯定比用多个线程来完成用的时间更短，为何仍需多线程呢？ 优点 1.提高应用程序的响应。对图形化界面更有意义，可增强用户体验。 2.提高计算机系统CPU的利用率 3.改善程序结构。将既长又复杂的进程分为多个线程，独立运行，利于理解和修改 提示：以下是本篇文章正文内容，下面案例可供参考 一、基本概念 1.程序 程序(program)是为完成特定任务、用某种语言编写的一组指令的集合。即指...
JavaSE笔记7.4-多线程-死锁
qq_38503984的博客
02-16 110
1. 多线程死锁 同步中嵌套同步，而锁却不同，导致锁无法释放 2. 代码 class Ticket implements Runnable{ private int num=500; Object obj=new Object(); boolean flag=true; public void run(){ if(flag){ ...
JAVASE_Notes:来自itheima黑马的JavaSE基础笔记
04-01
10. **多线程**：Java提供了内置的多线程支持，通过Thread类和Runnable接口可以创建并运行线程。线程同步和互斥的概念，如synchronized关键字和wait/notify机制也会有所介绍。 11. **反射机制**：Java反射机制允许...
javaSE笔记
03-14
JavaSE学习笔记，多线程，I/O流，集合，反射，常用设计模式
java8源码-JavaSE-Code:JavaSE的代码练习与学习笔记总结
06-04
第一章:Java多线程技能 线程是进程中的子任务 interrupted与isInterrupted的区别: interrupted是Thread类的静态方法,里面调用了isTnterrupted方法[currentThread().isInterrupted()],测试当前线程是否已经中断,线程...
javase笔记
01-24
此外，Java SE笔记还将涵盖更多内容，如Java语法、类与对象、接口、异常处理、集合框架、多线程、I/O流、网络编程等。每个主题都值得深入学习和实践，因为它们构成了Java编程的基础。通过不断练习和项目实战，你可以...
JavaSE笔记25：多线程（三）
qwq_666的博客
11-25 123
多线程（三） 线程安全 什么时候数据在多线程并发的环境下会存在安全问题 多线程并发 有共享数据 共享数据有修改行为 满足以上3个条件之后，就会存在线程安全问题 同步机制 如何解决？线程排队执行（不能并发），专业术语叫做“线程同步机制” ​ 用排队执行解决线程安全问题，这种机制被称为：线程同步机制。 注意：线程同步就是线程排队了，线程排队了就会牺牲一部分效率，没办法，数据安全第一位。只有数据安全了，我们才可以谈效率，数据不安全，没有效率的事。 说到线程同步这块，涉及到两个专业术语： 异步编程模型： 线
JavaSE笔记16：集合（二）
qwq_666的博客
11-08 761
集合（二） 上一篇：集合（一） 关于集合元素的remove 迭代过程中，不能直接通过集合删除元素，要通过迭代器删除元素 package se3.collection; import java.util.ArrayList; import java.util.Collection; import java.util.Iterator; public class CollectionTest06 { public static void main(String[] args) { C
JavaSE笔记15：集合（一）
qwq_666的博客
11-05 316
集合（一） 1.集合概述 数组其实就是一个集合，集合实际上就是一个容器，一个载体，可以容纳其他类型的数据，一次容纳多个对象 集合不能直接存储基本数据类，也不能直接存储java对象，集合当中存储的都是java对象的内存地址（或者说集合中存储的都是引用） 不同集合对应不同的数据结构 在java中每个不同的集合，底层会对应不同的数据结构，往不同的集合中存储元素，等于将数据放到了不同的数据结构当中。 这里只需要掌握怎么用？在什么情况下选择哪一种合适的集合去使用即可 new ArrayList(); 创建一个集
JavaSE笔记03流程控制
qwq_666的博客
10-18 309
Java流程控制 1.顺序结构 java的基本结构就是顺序结构，除非特别指明，否则就按照顺序一句一句往下执行。 顺序结构是最简单的算法结构，它是任何一个算法都离不开的一种基本算法结构。 2. 选择结构 1.if单选结构 语法： if(布尔表达式){ //如果布尔表达式为true将执行的语句 } 小例子 Scanner scanner = new Scanner(System.in); System.out.println("请输入内容："); String s = scanner.nextLi
JavaSE笔记13：基本类型对应的8个包装类
qwq_666的博客
11-01 245
基本类型对应的8个包装类 1.8种包装类存在的意义 java中为8种数据类型又对应准备了8种包装类型。8种包装类属于引用数据类型，父类是Object。 为什么要提供8种包装类呢？ 因为8种基本类型不够用 public class IntegerTest01 { public static void main(String[] args) { /*假设有需求：调用doSOme()方法的时候需要传一个数字进去， 但是数字属于基本数据类型，而doSOme方法参数
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值