JAVA多线程入门笔记1

最新推荐文章于 2024-10-09 23:44:37 发布
最新推荐文章于 2024-10-09 23:44:37 发布
阅读量115 收藏
点赞数
分类专栏： java 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/fanfanfanpp/article/details/120013538
版权

JAVA多线程入门笔记1

线程、进程、多线程

普通方法调用只有主线程一条执行路径，而多线程是多条执行路径，主线程和子线程并行交替执行。

一个进程可以有多个线程。

Process(进程)与Thread(线程)

说起进程，就不得不说下程序。程序是指令和数据的有序集合，其本身没有任何运行的含义，是一个静态的概念。

而进程则是执行程序的一次执行过程，它是一个动态的概念。是系统资源分配的单位。

通常在一个进程中可以包含若干个线程，当然一个进程中至少有一个线程，不然没有存在的意义。线程是CPU调度和执行的的单位。

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

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

线程创建

三种创建：

​ 1、继承Thread类

​ 2、实现Runnable接口

​ 3、实现Callable接口

继承Thread类

自定义线程类继承Thread类

重写run()方法，编写线程执行体

创建线程对象，调用start()方法启动线程

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

    public static void main(String[] args) {
        //创建一个线程对象
        TestThread1 testThread1 = new TestThread1();
        //调用start()方法开启线程
        testThread1.start();

        //main线程，主方法
        for (int i = 0; i < 2000; i++) {
            System.out.println("我在学习多线程"+i);
        }
    }
    //线程不一定立即执行，看CPU安排调度
}
案例：图片下载
//练习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() {
        webDownload webDownload = new webDownload();
        webDownload.downLoad(url,name);
        System.out.println("下载文件"+name);
    }

    public static void main(String[] args) {
       //图片地址自己随便在网上找几个
        TestThread2 t1 = new TestThread2("http://i0.hdslb.com/bfs/bangumi/image/36a46b1dd11081a5b6a1b65b9cf48eeec1ec2bd2.png@2320w_664h.png","p1.png");
        TestThread2 t2 = new TestThread2("http://i0.hdslb.com/bfs/bangumi/image/cd84ca2237b47d7b5b9bc9dd61e3a21ccb08e32e.png@90w_90h.webp","p2.webp");
        TestThread2 t3 = new TestThread2("http://i0.hdslb.com/bfs/album/8c26f6b4387b10823e6215b6505cf939bf9317aa.jpg@240w_320h_1e_1c.webp","p3.webp");

        t1.start();
        t2.start();
        t3.start();
    }

}

//下载器
class webDownload{
    //下载方法
    public void downLoad(String url,String name){
        try {
           //注意导入commons-io的jar包
            FileUtils.copyURLToFile(new URL(url),new File(name));
        } catch (IOException e) {
            e.printStackTrace();
            System.out.println("IO异常，downLoad方法出现问题");
        }
    }

}
实现Runnable接口

定义MyRunnable类实现Runnable接口

实现run()方法，编写线程执行体

创建线程对象，调用start()方法启动线程

推荐使用Runnable对象，为了避免JAVA单继承的局限性，方便同一个对象被多个线程使用

//创建线程方法二：实现Runnable接口，重写run方法，执行线程时丢入Runnable接口实现类，最后调用start方法
public class TestThread3 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) {
        //创建runnable接口实现类的对象
        TestThread3 testThread3 = new TestThread3();
        //创建线程对象，通过线程对象来开启我们的线程，代理
//        Thread thread = new Thread(testThread3);
//        thread.start();
        new Thread(testThread3).start();


        for (int i = 0; i < 2000; i++) {
            System.out.println("mian:"+i);
        }
    }
}
案例：图片下载
//练习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() {
        webDownload webDownload = new webDownload();
        webDownload.downLoad(url,name);
        System.out.println("下载文件:"+name);
    }

    public static void main(String[] args) {
        TestThread2 t1 = new TestThread2("http://i0.hdslb.com/bfs/bangumi/image/36a46b1dd11081a5b6a1b65b9cf48eeec1ec2bd2.png@2320w_664h.png","p1.png");
        TestThread2 t2 = new TestThread2("http://i0.hdslb.com/bfs/bangumi/image/cd84ca2237b47d7b5b9bc9dd61e3a21ccb08e32e.png@90w_90h.webp","p2.webp");
        TestThread2 t3 = new TestThread2("http://i0.hdslb.com/bfs/album/8c26f6b4387b10823e6215b6505cf939bf9317aa.jpg@240w_320h_1e_1c.webp","p3.webp");
//方法一
//        t1.start();
//        t2.start();
//        t3.start();

        //方法二
        new Thread(t1).start();
        new Thread(t2).start();
        new Thread(t3).start();
    }

}

//下载器
class webDownload{
    //下载方法
    public void downLoad(String url,String name){
        try {
            //注意导入commons-io的jar包
            FileUtils.copyURLToFile(new URL(url),new File(name));
        } catch (IOException e) {
            e.printStackTrace();
            System.out.println("IO异常，downLoad方法出现问题");
        }
    }
}
初识并发问题

多个线程操作同一个资源的情况下，线程不安全，会发生数据紊乱。

//多线程同时操作
//模拟抢票
public class TestThread4 implements Runnable{

    //抢票
    private int tickets = 20;

    @Override
    public void run() {
        while (true){
            if (tickets<=0){
                break;
            }
            //模拟延时
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+"抢到了第"+tickets--+"张票");
        }
    }

    public static void main(String[] args) {
        TestThread4 testThread4 = new TestThread4();
        //开启多个线程
        new Thread(testThread4,"aaa").start();
        new Thread(testThread4,"bbb").start();
        new Thread(testThread4,"ccc").start();
       //运行后发现，同一张票可能被不同线程抢到，出现数据紊乱
    }
}
实现Callable接口

1．实现Callable接口，需要返回值类型

2．重写call方法，需要抛出异常

3．创建目标对象

4．创建执行服务: ExecutorService ser = Executors.newFixedThreadPool(1);

5．提交执行: Future result1 = ser.submit(t1);

6．获取结果: boolean r1 = result1.get();

7．关闭服务: ser.shutdownNow();

//创建线程方法三：实现callable接口
//1、callable可以定义返回值
//2、callable可以抛出异常
public class TestCallable implements Callable<Boolean> {

    private String url;//图片下载地址
    private String name;//下载图片名

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

    //下载图片线程的执行体
    @Override
    public Boolean call() {
        webDownload webDownload = new webDownload();
        webDownload.downLoad(url,name);
        System.out.println("下载文件:"+name);
        return true;
    }

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        TestCallable t1 = new TestCallable("http://i0.hdslb.com/bfs/bangumi/image/36a46b1dd11081a5b6a1b65b9cf48eeec1ec2bd2.png@2320w_664h.png","p1.png");
        TestCallable t2 = new TestCallable("http://i0.hdslb.com/bfs/bangumi/image/cd84ca2237b47d7b5b9bc9dd61e3a21ccb08e32e.png@90w_90h.webp","p2.webp");
        TestCallable t3 = new TestCallable("http://i0.hdslb.com/bfs/album/8c26f6b4387b10823e6215b6505cf939bf9317aa.jpg@240w_320h_1e_1c.webp","p3.webp");


        //创建执行服务:
        ExecutorService ser =  Executors.newFixedThreadPool(3);

        //提交执行:
        Future<Boolean> result1 = ser.submit(t1);
        Future<Boolean> result2 = ser.submit(t2);
        Future<Boolean> result3 = ser.submit(t3);

        //获取结果:
        boolean r1 = result1.get();
        boolean r2 = result2.get();
        boolean r3 = result3.get();

        System.out.println(r1);
        System.out.println(r2);
        System.out.println(r3);
        //关闭服务:
        ser.shutdownNow();

    }

}

//下载器
class webDownload{
    //下载方法
    public void downLoad(String url,String name){
        try {
            //注意导入commons-io的jar包
            FileUtils.copyURLToFile(new URL(url),new File(name));
        } catch (IOException e) {
            e.printStackTrace();
            System.out.println("IO异常，downLoad方法出现问题");
        }
    }
}
静态代理模式
//接口Marry
public interface Marry {
    //都要完成的动作
    void HappyMarry();
}



//真是角色对象，You类
public class You implements Marry {
    @Override
    public void HappyMarry() {
        System.out.println("结婚了");
    }
}



//代理对象，帮助你结婚，WeddingCompany类
public class WeddingCompany implements Marry {

    //接收代理的真实对象
    private Marry target;

    public WeddingCompany(Marry target){
        this.target = target;
    }

    @Override
    public void HappyMarry() {
        before();
        this.target.HappyMarry();//调用真实对象的HappyMarry函数
        after();
    }

    private void after() {
        System.out.println("结婚之后，收取服务费");
    }

    private void before() {
        System.out.println("结婚之前，布置现场");
    }
}




//静态代理模式总结
//真实对象和代理对象都实现同一个接口
//代理对象代理真实对象

//优点
//代理对象可以做很多真实对象做不了的事情
//真实对象专注做自己的事情
public class Staticproxy{

    public static void main(String[] args){
        //You you = new You();
//        WeddingCompany weddingCompany = new WeddingCompany(you);
//        weddingCompany.HappyMarry();
        new WeddingCompany(new You()).HappyMarry();

        //实现Runnable接口创建线程的方法实际是一种静态代理模式
        //Thread类实现了Runnable接口，相当于代理对象
        //自己编写的类也实现了Runnable接口，相当于真实对象
        //本例中的HappyMarry方法相当于线程中的start方法
        new Thread(()->System.out.println("111")).start();
    }
}

帮助理解的参考文章

参考理解文章一

参考理解文章二

Lambda表达式(补充)

  • 避免匿名内部类定义过多
  • 去掉没有意义的代码，只留下核心的逻辑
  • Functional interface(函数式接口)：任何接口，如果只包含唯一一个抽象方法，那么它就是一个函数式接口。对于函数式接口，可以通过lambda表示式来创建该接口的对象。
public class TestLambda1 {
//3、静态内部类
    static class Student2 implements Stud{

    @Override
    public void say(int a) {
        System.out.println("lambda2静态内部类"+a);
    }
}

    public static void main(String[] args) {
        Stud student = new Student1();
        student.say(1);

        student = new Student2();
        student.say(2);

        //4、局部内部类
        class Student3 implements Stud{

            @Override
            public void say(int a) {
                System.out.println("lambda3局部内部类"+a);
            }
        }

        student = new Student3();
        student.say(3);

        //5、匿名内部类、没有类的名称，必须借助接口或者父类
        student = new Stud() {
            @Override
            public void say(int a) {
                System.out.println("Lambda4匿名内部类"+a);
            }
        };
        student.say(4);

        //6、通过lambda表达式简化
        student = (int a)->{
            System.out.println("lambda5-lambda表达式"+a);
        };
        student.say(5);

        //当代码简单时还可以简化
        student= a->System.out.println("lambda5-lambda表达式"+a);
        student.say(10);
    }

}

//1、定义一个函数式接口
interface Stud{
   public abstract void say(int a);
}

//2、实现类
class Student1 implements Stud{

    @Override
    public void say(int a) {
        System.out.println("lambda1实现类"+a);
    }
}

使用时注意：

  • lambda表达式只能在只有一行代码时简化为一行。多行代码必须由{}包裹。
  • 前提接口必须为函数式接口。
  • 当有多个参数时，必须加上括号，可以去掉参数类型。

详情www.kuangstudy.com

fan凡fan
关注
专栏目录
Java多线程（多线程基本操作，多线程安全问题等）
2401_84048338的博客
05-04 1030
自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。深知大多数Java工程师，想要提升技能，往往是自己摸索成长，自己不成体系的自学效果低效漫长且无助。因此收集整理了一份《2024年Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。
零基础Java入门课程-多线程
07-01
在IT行业中，Java是一种广泛应用的编程语言，尤其在企业级...文档"零基础Java入门课程-多线程-20201217202008101.docx"很可能是课程的详细讲义或笔记，包含了上述知识点的详细解释和实例，建议仔细研读，以加深理解。
Java多线程学习笔记
liuzuoping的博客
04-22 361
Java多线程学习（一）Java多线程入门 Java多线程学习（二）synchronized关键字（1） Java多线程学习（二）synchronized关键字（2） Java多线程学习（三）volatile关键字 Java多线程学习（四）等待/通知（wait/notify）机制 Java多线程学习（五）线程间通信知识点补充 Java多线程学习（六）Lock锁的使用 ...
Java多线程入门笔记
Zunderdog的博客
01-28 340
所以无法再继承Tread以外其他类。以上内容在b站尚硅谷网课中学习总结。
Java多线程 入门
suen的博客
07-29 667
前言 第一次系统的接触多线程（B站老韩的课），写了点笔记用来反思总结 Java多线程入门前言基本概念进程线程相关概念线程基本使用创建线程三种方式示例代码继承Thread实现Runnable区别 继承Thread 实现Runnable接口终止线程Thraed类常用方法代码线程的 7 种状态锁Synchronized关键字线程同步机制具体同步方法Java中常见的锁互斥锁死锁释放锁线程正常释放锁的情况线程不释放锁的情况总结 基本概念 进程 运行中的程序，是系统进行资源分配和调度的基本单位，是操作系统结构的.
Java多线程实战-CompletableFuture异步编程优化查询接口响应速度
热门推荐
qq_35716689的博客
03-20 25万+
CompletableFuture为Java提供了强大的异步编程能力,可以极大地提高应用的并发能力和响应速度。通过并行执行多个查询任务,我们可以大幅减少接口的响应时间,优化用户体验。同时,CompletableFuture的代码风格函数式、简洁、优雅,也使得代码更加易读易维护。 但是,异步编程也不是万能的,它需要开发者转变思维模式,还需要权衡利弊。在实际项目中,我们可以结合其他优化手段,选择合适的方案,以达到最佳的性能效果。
Java多线程入门(二)
qq_44525150的博客
06-07 2068
本文简要介绍了Java多线程中的线程同步的作用，实现线程同步的三种方法，什么是线程死锁，线程死锁的例子，线程的状态，线程的生命周期
超详细的多线程笔记—从Java多线程入门到JUC并发编程
05-04 962
一、需要掌握的前置概念与知识二、Java实现多线程三、Thread类学习四、线程不安全五、JUC中的Locks包六、进程通信与线程间通信七、死锁问题与死锁避免八、八锁现象彻底理解锁九、线程安全的集合十、Callable详解十一、JUC辅助类详解十二、线程池
Java基础知识整理笔记
是袁同学呀
06-27 1161
个人闲暇整理的Java基础知识笔记，偏向对于常见面试问题的答案整理，能力有限，非系统性的知识总结。
Java，commons io包实现多线程同步图片下载入门(1)
2301_79099287的博客
04-29 542
/联系Thread，实现多线程同步下载图片//网络图片地址//保存的文件名//下载图片线程的执行体。@OverrideSystem.out.println(“下载了文件名为：”+name);//下面的URL是在我自己的博客中找的图片的url。//先下载t1,t2,t3。但是是同时执行的，多线程！t1.start();t2.start();t3.start();//下载器//下载方法try {
这篇文章就是要让你入门java多线程【多线程入门】
宜春
11-20 1万+
就在前几天，有位朋友私信宜春，说期待出一篇多线程的文章，我当时内心是小鹿乱撞啊....于是这几天茶不思饭不想，好几天深夜皆是辗转反侧，两目深凝，以至于这几天走起路来格外飘飘然~我承认太夸张了，感觉又要被打~。最终还是君意不可违，答应了这位朋友，从这位朋友的头像可以看出来，这位朋友绝bi历经沧桑，对生活无尽的坦然浩对，看透俗世凡尘、世态炎凉、趋炎附势，拥有着极高的安心恬荡情怀...啥？啥子？这个是系统默认头像....那个那个宜春啥都没说哈，别把什么事都扯宜春身上，我啥都没说。。。。
java入门笔记.pdf
08-12
Java多线程部分详细解释了如何创建和管理线程、线程池的使用、volatile关键字、死锁、线程通信和同步机制。文档中也提及了Java 5中引入的一些并发工具类，比如Future、Callable、Fork/Join框架，以及JDK 8对并发编程...
java从入门到精通学习笔记-Lesson5(多线程).pdf
11-12
Java 多线程是编程中的重要概念，尤其对于并发处理和高效系统设计至关重要。在Java中，多线程是通过两种主要方式实现的：继承`Thread`类或实现`Runnable`接口。 首先，理解基本概念：程序是静态的指令集合，而进程...
C语言 | 第十章 | 函数 作用域
ZJC744575的博客
10-05 1211
为完成某一功能的程序指令(语句)的集合,称为函数。在C语言中,函数分为:自定义函数、系统函数(查看C语言函数手册)函数还有其它叫法，比如方法等，在本视频课程中，我们统一称为 函数。返回类型 函数名（形参列表）{执行语句...;// 函数体return 返回值;// 可选形参列表：表示函数的输入函数中的语句：表示为了实现某一功能代码块函数可以有返回值,也可以没有, 如果没有返回值，返回类型 声明为 void。
JDK1.0主要特性
FoolRabbit的专栏
10-06 356
JDK1.0主要特性。
JavaScript ArrayBuffer的读写与类型转换
白瑕 的博客
10-01 520
所有视图的基本单位是ArrayBuffer, ArrayBuffer中只存储二进制格式的数据.ArrayBuffer不可直接读写, 必须通过视图(比如DataView)暴露的API.
Netty 相比原生IO模型的优势
lssffy的博客
10-09 329
Java提供了多种I/O模型，每种模型都有其适用的场景和特点，随着网络应用需求的变化，I/O模型也在不断发展。阻塞I/O（BIO，Blocking I/O）传统的I/O模型，使用简单，但每次I/O操作都会阻塞线程。每个请求需要独立的线程来处理，这在并发请求较少时问题不大，但在高并发情况下，线程资源将成为瓶颈。非阻塞I/O（NIO，Non-Blocking I/O）引入了多路复用技术，一个线程可以处理多个连接，避免了BIO中每个连接占用一个线程的问题。通过Selector。
JAVA开源项目 旅游管理系统 计算机毕业设计
as230627的博客
10-03 1353
旅游管理系统基于Springboot框架、JAVA编程语言、MYSQL数据库开发完成，“操作简单，功能实用”这是本软件设计的核心理念，本系统力求创造最好的用户体验。
Apache Flink Dashboard
最新发布
qq_41081716的博客
10-09 228
并行度，可以运行一个任务实例。已完成、取消和失败的作业数量。
Java多线程入门指南：概念、创建与实战
Java多线程编程笔记是针对初学者精心整理的一份资料，旨在帮助学习者掌握Java中多线程的基本概念和实践。主要内容涵盖了以下几个关键知识点： 1. **操作系统中的线程与进程**： - 在多任务操作系统中，进程是运行...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值