java多线程学习

于 2023-07-10 22:18:29 发布
阅读量105 收藏
点赞数
文章标签： java 学习 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_64749417/article/details/131648781
版权

声明：本人java学习记录笔记都来自于B站“遇见狂神说”的视频教学，本人java小白，只为每天记录下学习总结。
视频地址：遇见狂神说的个人空间-遇见狂神说个人主页-哔哩哔哩视频

1线程的一些概念

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

2线程的创建

三种方法：

一、继承Thread类

二、实现Runnable接口

三、实现Callable接口

（1）第一种方法

首先，自定义线程类继承Thread类；其次，重写run()方法，编写线程执行体；最后，创建线程对象，调用start()方法启动线程。

示例代码如下:

package com.ly.Thread;

//创建线程方式一：继承Thread类，重写run()方法，调度start开始线程

//总结：线程开始不一定执行，由CPU调度

public class TestThrea1 extends Thread{
    @Override
    public void run() {
        //run方法线程体
        for (int i = 0; i < 20; i++) {
            System.out.println("我在看代码---"+i);
        }
    }


    //main方法，主线程
    public static void main(String[] args) {
        //创建一个线程对象,new
        TestThrea1 testThrea1 = new TestThrea1();
        //调用start()方法开启线程,这样就是子线程运行run方法，如果调用run方法，则是主线程执行run方法
        testThrea1.start();



        for (int i = 0; i < 10; i++) {
            System.out.println("在学习多线程---"+i);
        }
    }
}

 用第一种方法实现多线程图片下载：

package com.ly.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;
        }

        //run方法就是线程的执行体
        @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("https://pic3.zhimg.com/v2-3b83e03ec8352b504e7a3dab903a9c66_r.jpg","1.jpg");
                TestThread2 t2 = new TestThread2("https://pic3.zhimg.com/v2-3b83e03ec8352b504e7a3dab903a9c66_r.jpg","2.jpg");
                TestThread2 t3 = new TestThread2("https://pic3.zhimg.com/v2-3b83e03ec8352b504e7a3dab903a9c66_r.jpg","3.jpg");

                t1.start();
                t2.start();
                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异常");
                }

        }

}

（2）第二种方法

首先，定义MyRunnable类实现Runnable接口；其次，实现run()方法，编写线程执行体；最后，创建线程对象，调用start()方法启动线程。

示例代码如下：

package com.ly.Thread;


//创建线程方法2：实现runnable接口，重写run方法，执行线程需要丢入runnable接口实现，调用start
public class TestThread3 implements Runnable{

    //run方法就是线程的执行体
    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            System.out.println("我在看代码---"+i);
        }
    }

    public static void main(String[] args) {
        //创建runnable接口的实现类对象
        TestThread3 testThread3 = new TestThread3();
        new Thread(testThread3).start();

        for (int i = 0; i < 20; i++) {
            System.out.println("我在学习多线程---"+i);
        }
    }

}

用第二种方法实现多线程购票：

package com.ly.Thread;

public class TestThread4 implements Runnable{

    private int ticketNums = 10;


    @Override
    public void run() {
        while (true){
            if (ticketNums <= 0){
                break;
            }

            //模拟延时,try-catch快捷键：ctrl+alt+t
            try {
                Thread.sleep(200);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            System.out.println(Thread.currentThread().getName()+"-->拿到了第"+ticketNums--+"票");
        }
    }
    //开始主线程，进行一个对象，多个代理
    public static void main(String[] args) {
        //实例化
        TestThread4 testThread4 = new TestThread4();
        //调用start
        new Thread(testThread4,"明").start();
        new Thread(testThread4,"红").start();
        new Thread(testThread4,"华").start();
    }
}

发现并发问题：多个线程操作同一个资源的影响下，线程不安全，数据紊乱。

用第二种方法实现龟兔赛跑：

package com.ly.Thread;

public class TestThread5 implements Runnable{

    //胜利者
    private static String winner;

    @Override
    public void run() {
        for (int i = 0; i <= 100; i++) {

            //加延时模拟兔子睡觉
            if (Thread.currentThread().getName().equals("兔子")){
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }

            //判断比赛是否结束
            boolean flag = gameOver(i);
            //如果比赛结束就停止程序
            if (flag){
                break;
            }

            System.out.println(Thread.currentThread().getName()+"跑了"+i +
                    "步");
        }
    }

    //判断是否完成比赛
    private boolean gameOver(int steps){
        //判断是否有胜利者
        if (winner!=null){//已经存在胜利了
            return true;
        }else if (steps == 100){
            winner = Thread.currentThread().getName();
            System.out.println("winner is"+winner);
            return true;
        }
        return false;
    }


    public static void main(String[] args) {
        TestThread5 testThread5 = new TestThread5();

        new Thread(testThread5, "兔子").start();
        new Thread(testThread5, "乌龟").start();
    }
}

总结一、二种方法：

继承Thread类：
        子类继承Thread类具备多线程能力

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

（3）第三种方法

实现步骤：

1.实现callable接口，需要返回值类型

2.重写call方法，需要抛出异常
3.创建目标对象
4.创建执行服务:ExecutorService ser = Executors.newFixedThreadPool(1);

5.提交执行:Future<Boolean> result1 = ser.submit(t1);
6.获取结果: boolean r1 = result1.get()
7.关闭服务: ser.shutdownNow();

图片下载示例代码如下：

package com.ly.Thread;

import org.apache.commons.io.FileUtils;

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

public class TestThread6 implements Callable<Boolean> {

    private String url;//网络异常图片地址
    private String name;//保存的文件名

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

    //run方法就是线程的执行体
    @Override
    public Boolean call() {
        WebDownLoader2 webDownLoader = new WebDownLoader2();
        webDownLoader.downloader(url, name);
        System.out.println("下载了文件名为："+name);
        return true;
    }

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        TestThread6 t1 = new TestThread6("https://pic3.zhimg.com/v2-3b83e03ec8352b504e7a3dab903a9c66_r.jpg","1.jpg");
        TestThread6 t2 = new TestThread6("https://pic3.zhimg.com/v2-3b83e03ec8352b504e7a3dab903a9c66_r.jpg","2.jpg");
        TestThread6 t3 = new TestThread6("https://pic3.zhimg.com/v2-3b83e03ec8352b504e7a3dab903a9c66_r.jpg","3.jpg");


        //创建执行服务
        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();

        System.out.println(rs1);
        System.out.println(rs2);
        System.out.println(rs3);
        //关闭服务
        ser.shutdownNow();
    }
}


//下载器
class WebDownLoader2{
    //下载方法
    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异常");
        }

    }

}

这里我是首次遇到线程池，在之后的学习中视频还会细讲。

【爱吃橘子】
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
Java的多线程应该怎么学（看完这里你就知道了）
java_xiaoo的博客
09-23 231
spring中bean默认都是单例的，但是spring接受并发请求是线程安全的，就是因为使用threadlocal把请求，上下文数据装在了线程里。：使用lock和unlock实现加锁和解锁，可使用ReadWriteLock读写锁来实现读和写的锁分离，底层使用CAS和AQS实现，这也是很多。JAVA中的多线程使用十分广泛，很多的JAVA框架都使用到了多线程，比如spring，mybatis，①，synchronize：锁方法，锁代码段，锁对象，锁的粒度大！2，countdownbatch用做计数器！
Java多线程学习（超详细）
qq_46940224的博客
06-25 1448
Java线程
java学习-多线程
weixin_49349476的博客
04-16 131
java实现线程创建的三种方式：1、继承Thread类；2、 实现Runnable接口；3、通过Callable接口实现
Java多线程学习（基础篇）
nelson的博客
08-08 8168
第一节 1. java对线程的支持 java对线程的支持主要体现在Thread类以及Runable接口上，他们都位于java.lang包下，无论是Thread类还是Runable接口，它们都有public void run()方法，这个run方法为我们提供了线程实际工作时的代码，换句话说，我们的逻辑代码就可以写在run方法体中。 2. 线程的创建和启动 3. 线程的常用方法 ...
Java多线程学习 （超详细总结）
Jieur的博客
01-16 1664
Java多线程学习一、概要二、 JAVA 线程实现/创建方式2.1 继承Thread 类2.2 实现 Runnable 接口2.3 Thread和Runnable的区别2.4 总结三、线程生命(状态)3.1 解释：3.2 新建状态（NEW）:3.3 就绪状态（RUNNABLE）：3.4 阻塞状态（BLOCKED）:3.4.1 等待阻塞（o.wait->等待对列）3.4.2 同步阻塞(lock->锁池)3.4.3 其他阻塞(sleep/join)3.5 线程死亡（DEAD）四、线程调度4.1
java学习之多线程
qq_40523277的博客
09-11 100
目录 同步&&异步 并发&&并行 多线程技术： 线程技术———接口方法 对比多线程技术中两个方法（Thread / Runnable）Runnable所具有的优势： 设置获取线程名称和线程休眠方法 守护线程： 线程安全问题： 显式锁和隐式锁的区别： 线程池： 同步&&异步 同步：排队执行效率低但是安全； 异步：同时执行效率高但是数据不安全； 并发&&并行 并发：两个或两个以上事件在同一时间段内发生； ..
Java多线程学习总结
09-14
Java多线程是编程中的重要概念，尤其在开发高并发、高性能的应用时不可或缺。本文将深入探讨Java中的线程和进程，以及如何在Java中实现多线程。 首先，理解线程和进程的概念至关重要。线程是操作系统分配CPU时间片...
java多线程学习视频
10-30
Java多线程是一块重要的内容，李兴华讲解的Java是一个很好的资源
Java多线程学习Java多线程学习Java多线程学习Java多线程学习.txt
最新发布
05-15
Java多线程学习Java多线程学习Java多线程学习Java多线程学习Java多线程学习Java多线程学习Java多线程学习Java多线程学习Java多线程学习Java多线程学习Java多线程学习Java多线程学习Java多线程学习Java多线程学习Java...
JAVA多线程学习详细总结
盛难晨
05-27 618
什么是线程和进程？ 进程： 进程是程序的一次执行过程，是系统运行程序的基本单位，因此进程是动态的。系统运行一个程序即是一个进程从创建，运行到消亡的过程。 在java中，当我们启动main函数时就是启动了一个JVM的进程，而main函数所在的线程就是这个进程中的一个线程，也称主线程。 线程： 线程和进程相似，但线程是一个比进程更小的执行单位。一个进程在其执行过程中可以产生多个线程。 在java中，当我们启动main函数时其实就是启动了一个JVM的进程，而main函数所在的线程就是在这个进程的一个线程，也称为主
JAVA基础学习- 多线程
qq_25687271的博客
05-10 368
1、线程的基本概念 程序：是一段可执行的静态代码 进程：程序的一次动态加载过程（将程序加载到内存时，此时程序就转换为了进程） 线程： 进程可进一步细化为线程，是一个程序内部的一条执行路径，线程不能独立存在，必须依附于某个进程 一个Java应用程序，至少有三个线程： main线程，垃圾回收线程，异常处理线程 多个线程共享进程的堆和方法区资源，但每个线程有自己的程序计数器、虚拟机栈和本地方法栈 2、使用多线程的优点 优点在于充分利用了CPU的空闲时间片，用尽可能少的时间来对用户的要求做出响应
Java多线程学习（吐血超详细总结）
热门推荐
Evankaka的专栏
03-14 41万+
本文主要讲了java中多线程的使用方法、线程同步、线程数据传递、线程状态及相应的一些线程函数用法、概述等。
Java技术——Java多线程学习
关于Android开发的一些技术点总结 ╮(￣▽￣”)╭
09-01 1万+
0.前言 转载请标明出处：http://blog.csdn.net/seu_calvin/article/details/52400927 学习多线程之前需要先了解以下几个概念。 进程：一般指一个程序运行时的实例，每个进程有自己独立的地址空间。一个进程无法直接访问另一个进程的数据。 线程：是CPU调度的最小单元，一个进程可以有很多线程，每条线程可以并行执行不同的任务。并且每个线程有独立的运...
学习笔记：Java高级编程之多线程
Red_super的博客
10-14 313
学习笔记： 线程的操作状态（阻塞） 学习内容： 注意：之所以图中有7个状态，是因为 在jdk5之后，就绪和运行状态统称为Runnable 1、new（初始化状态）：在程序中用构造方法创建一个线程对象后，新的线程对象边处于新建状态，此时，它已经有相应内存空间和其他资源，但还处于不可运行状态。就是你实例化了一个对象，但是还没有开始调用方法。 2、 Runnable（可运行状态）： 上面说了Runnable包含了就绪和运行状态，而且这也是核心状态。 （1）就绪状态： 新建线程对象后，调用该线程的st
如何学习Java多线程
SexyCode
04-09 3668
最近一段时间，我对《Java并发编程实践》这本经典而又有些难懂的书籍，尝试用了一些简单有趣、通俗易懂的方式进行解读，现整理成GitBook（文末有链接），方便大家阅读。
大聪明教你学Java | 带你学习Java多线程
不肯过江东丶
10-27 7487
前言 相信每一位程序猿对“多线程”这个概念应该都不陌生，无论是在开发还是面试的时候，都会遇到多线程的问题。不过，一定有很多小伙伴才刚刚接触到多线程，那么在此就由小弟为各位小伙伴细细说说什么是多线程。 在开始之前，先简单介绍一下什么是线程～ Java 给多线程编程提供了内置的支持。 一条线程指的是进程中一个单一顺序的控制流，一个进程中可以并发多个线程，每条线程并行执行不同的任务。 多线程是实现并发机制的一种有效手段。进程和线程一样，都是实现并发的一个基本单位。线程是比进程更小的执行单位，线程是进程的基础之上进
Java 多线程学习
hua226的博客
04-13 2万+
Java 多线程 一、实现多线程 1.1 进程 进程：是正在运行的程序 是系统进行资源分配和调用的独立单位 每一个进程都有它自己的内存空间和系统资源 1.2 线程 线程：是进程中的单个顺序控制流，是一条执行路径 单线程：一个进程如果只有一条执行路径，则称为单线程程序 多线程：一个进程如果有多条执行路径，则称为多线程程序 1.3 多线程的实现方式 多线程的实现方案有两种： 继承Thread类 实现Runnable接口 方式1：继承Thread类 定义一个MyThread类继承Thread类 在M
java多线程 学习
04-19
Java多线程是指在Java程序中同时执行多个线程的机制。通过使用多线程，可以实现并发执行，提高程序的效率和响应性。在Java中，可以通过以下几种方式来实现多线程： 1. 继承Thread类：创建一个继承自Thread类的子类...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值