多线程学习笔记

最新推荐文章于 2024-10-06 20:16:20 发布
最新推荐文章于 2024-10-06 20:16:20 发布
阅读量248 收藏
点赞数
文章标签： 多线程 java thread 并发编程 多进程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/curry123456/article/details/109004346
版权

线程核心介绍：

在这里插入图片描述

1.实现线程的方法

1.通过继承thread来实现

public class ThreadTest extends Thread{
    public void run(){
        for (int i = 0; i <1000 ; i++) {
            System.out.println("run方法"+i);
        }
    }

    public static void main(String[] args) {
        ThreadTest t1=new ThreadTest();
        t1.start();

        for (int i = 0; i <1000 ; i++) {
            System.out.println("main方法"+i);
        }

    }
}

注意：线程开启不一定立即执行，由cpu调度完成。

2.通过runnable接口来实现

package com.company;

public class ThreadTest01 implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i <2000 ; i++) {
            System.out.println("run"+i);
        }
    }

    public static void main(String[] args) {

        ThreadTest01 t1=new ThreadTest01();
        new Thread(t1).start();
        for (int i = 0; i <1000 ; i++) {
            System.out.println("main"+i);
        }
    }
}

3.二者对比

在这里插入图片描述

2.初识并发性

1.抢票范例

package com.company;

public class ThreadTest02 implements Runnable {
    private int ticketCount=10;
    @Override
    public void run() {
        while (true){
            if(ticketCount<=0){
                break;
            }
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+"抢到了第"+ticketCount--+"张票");
        }
    }

    public static void main(String[] args) {
        ThreadTest02 threadTest02=new ThreadTest02();
        new Thread(threadTest02,"小明").start();
        new Thread(threadTest02,"黄牛").start();
    }
}

2.龟兔赛跑

package com.company;

public class Race implements Runnable {
    public static String winner;
    public void run() {
        for (int i = 0; i <=101 ; i++) {
            boolean flag=GameOver(i);
            if(flag){
                break;
            }
            System.out.println(Thread.currentThread().getName()+"跑了"+ i +"步");
        }

    }

    public boolean GameOver(int step){
        if(winner!=null){
            return true;
        }else if(step>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.静态代理模式

package com.company;
//静态代理模式总结：
//代理角色和真实角色要实现同一个接口
//代理角色代理真实角色

public interface StaticProxy {
    void marry();
}
class WeedingPerson implements  StaticProxy{

    @Override
    public void marry() {
        System.out.println("结婚了很开心");
    }
}
class MarryCompany implements StaticProxy{
public static WeedingPerson weedingPerson;

    public MarryCompany(WeedingPerson weedingPerson){
        this.weedingPerson=weedingPerson;
    }

    @Override
    public void marry() {
        before();
        this.weedingPerson.marry();
        after();
    }

    private void after() {
        System.out.println("数钱");
    }

    private void before() {
        System.out.println("布置现场");
    }
}

class Test{
    public static void main(String[] args) {
        WeedingPerson weedingPerson=new WeedingPerson();
        MarryCompany marryCompany=new MarryCompany(weedingPerson);
        marryCompany.marry();
    }
}

4.lamda表达式

1.函数式接口

在这里插入图片描述

2.代码实现

package com.baidu.www;

public class TestLamda {
    //静态内部方法
    static class Lamdad1 implements Lamda {

        @Override
        public void f() {
            System.out.println("输出f1方法");
        }

        public static void main(String[] args) {

            Lamda lamda = new Lamdad();
            lamda.f();
            lamda = new Lamdad1();
            lamda.f();
      //局部内部方法
            class Lamdad2 implements Lamda {

                @Override
                public void f() {
                    System.out.println("输出f2方法");
                }
            }

            lamda = new Lamdad2();
            lamda.f();

            //匿名内部类

            lamda=new Lamdad() {
                @Override
                public void f() {
                    System.out.println("输出f3方法");
                }
            };

            lamda.f();

            //lamda表达式
            lamda= ()->{
                System.out.println("输出f4");
            };
            lamda.f();
        }
    }
}

    //定义一个函数式接口
    interface Lamda {
        void f();
    }
//接口实现类
    class Lamdad implements Lamda {

        @Override
        public void f() {
            System.out.println("输出f方法");
        }
    }

5.线程的五大状态

1.线程生命周期

在这里插入图片描述

2.线程方法

在这里插入图片描述

3.线程停止代码操作

package com.baidu.www;

public class ThreadTest03 implements Runnable{
    //外部标志位
    boolean flag=true;
    @Override
    public void run() {
        int i=0;
        while(flag){

                System.out.println("线程运行"+i++);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }


        }
    }

    public void stop(){
        this.flag=false;
    }

    public static void main(String[] args) throws InterruptedException {
        ThreadTest03 threadtest03=new ThreadTest03();
        new Thread(threadtest03).start();
        for (int i = 0; i <10 ; i++) {
            Thread.sleep(1000);
            System.out.println("主线程"+i);
            if(i==4){
                threadtest03.stop();
                System.out.println("线程停止");
            }
        }
    }
}

4.线程休眠

在这里插入图片描述

5.礼让方法

在这里插入图片描述

6.join方法

简单，一笔带过，类似于插队。

6.线程状态

1.代码演示

package com.baidu.www;

public class ThreadTest04 {

    public static void main(String[] args) {
        Thread thread=new Thread(()->{
            for (int i = 0; i <5 ; i++) {
                try {
                    Thread.sleep(1000);
                    System.out.println("线程开启"+i);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println("/");

        });


        Thread.State state=thread.getState();
        System.out.println(state);//线程创建
        thread.start();
        state=thread.getState();
        System.out.println(state);//线程启动

    }

}

2.线程的优先级

在这里插入图片描述

1.代码演示
package com.baidu.www;



public class PriorityTest implements Runnable  {
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"线程的优先级"+Thread.currentThread().getPriority());
    }
    public static void main(String[] args) {
        PriorityTest priorityTest=new PriorityTest();

        Thread t2=new Thread(priorityTest,"t2");
        Thread t3=new Thread(priorityTest,"t3");
        t2.setPriority(Thread.MIN_PRIORITY);
        t3.setPriority(Thread.MAX_PRIORITY);
        t2.start();
        t3.start();
    }


}

3.守护线程

在这里插入图片描述

注释：一句话，用户线程结束，守护线程也结束；

注释：将setDeamon(true);//即为守护线程

7.并发

1.线程同步

在这里插入图片描述

在这里插入图片描述

注释：并发：多个线程同时操作一个对象

synchronized

2.线程不安全实例代码演示

1.抢票实例(已加入synchronized变成同步方法)
package com.baidu.www;

public class UnsafeBuyTicket implements Runnable {

private int ticketNmuber=10;
private boolean flage=true;
    @Override
    public void run() {
        while(flage){
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            buy();
        }

    }
    //买票
    public synchronized void buy(){//加入synchronized关键字变成同步方法
        if(ticketNmuber<=0){
            flage =false;
            return;
        }else if(ticketNmuber<=10){
            flage=true;
            System.out.println(Thread.currentThread().getName()+"拿到了第"+ticketNmuber--+"张票");
            return;

        }
    }

    public static void main(String[] args) {
UnsafeBuyTicket unsafe=new UnsafeBuyTicket();
new Thread(unsafe,"小明").start();
new Thread(unsafe,"黄牛").start();
    }
}
2.银行取钱实例（已加入synchronized变成同步块）
package com.baidu.www;

public class UnsafeBank  {
    public static void main(String[] args) throws InterruptedException {
        BankCount bankCount=new BankCount("结婚基金",100);
        System.out.println("账户里有"+bankCount.bankmoney);
        DrawingMoney yb=new DrawingMoney(bankCount,50,"易彪");
        DrawingMoney yx=new DrawingMoney(bankCount,100,"杨欣");
        new Thread(yb).start();
        new Thread(yx).start();


    }

}
class BankCount{
    String username;
    int bankmoney;//银行账户有多少钱

    public BankCount(String username, int bankmoney) {
        this.username = username;
        this.bankmoney = bankmoney;
    }
}
class DrawingMoney implements Runnable{
  static   BankCount bankCount;
    int nowMoney;//现在手里有多少钱
    int drawingMoney;//要取多少钱
    String name;

    public DrawingMoney(BankCount bankCount, int drawingMoney, String name) {
        this.name=name;
        this.bankCount = bankCount;
        this.drawingMoney=drawingMoney;
    }
    public void run() {
        synchronized(bankCount){
            if(bankCount.bankmoney<drawingMoney) {
                System.out.println("钱不够，取不出来");
                return;
            }else {

                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {


                }
                //银行卡账户余额
                bankCount.bankmoney = bankCount.bankmoney - drawingMoney;
                //你手里的钱
                nowMoney = nowMoney + drawingMoney;
                System.out.println(this.name + "的手里有" + nowMoney);
                System.out.println(bankCount.username + "的余额为" + bankCount.bankmoney);
            }
        }

    }
}
3.ArrayList不安全实例（已加入synchronized变成同步块）
package com.baidu.www;

import java.util.ArrayList;
import java.util.List;

public class ArrayListTest implements Runnable{
    public static void main(String[] args) throws InterruptedException {
        List<String> list=new ArrayList<>();

            synchronized (list) {//加入synchronized关键字变成同步块
                    for (int i = 0; i < 10; i++) {
                    Runnable thread;
                    thread = () -> {
                        list.add(Thread.currentThread().getName());

                    };
                    new Thread(thread).start();

                }
            }
        Thread.sleep(1000);
        System.out.println(list.size());
        }



    @Override
    public void  run() {

    }
}

8.同步方法和同步方法块

1.同步方法概念

在这里插入图片描述

2.同步方法块概念

在这里插入图片描述

9.死锁

1.什么是死锁

在这里插入图片描述

2.死锁的必要条件

在这里插入图片描述

3.死锁的代码演示



package com.baidu.www;

public class DeadLock {
    public static void main(String[] args) {
        Person yx = new Person(0, "杨欣");
        Person yb = new Person(1, "阿彪");
        //Person yt= new Person(1, "阿");
        new Thread(yx).start();
        new Thread(yb).start();
        //new Thread(yt).start();

    }
}

class lipstick {

}

class mirror {

}

class Person implements Runnable {
    //保证需要的资源只有一份
    static lipstick lipstick = new lipstick();
    static mirror mirror = new mirror();
    int choice;
    String name;

    public Person(int choice, String name) {
        this.choice = choice;
        this.name = name;
    }


    public void makeup() throws InterruptedException {

        if (choice == 0) {
            synchronized (lipstick) {
                System.out.println(this.name + "获得了口红的锁");
                Thread.sleep(1000);
            }
            synchronized (mirror) {
                System.out.println(this.name + "获得了镜子的锁");

            }

        } else {
            synchronized (mirror) {
                System.out.println(this.name + "获得了镜子的锁");
                Thread.sleep(1000);
            }
            synchronized (lipstick) {
                System.out.println(this.name + "获得了口红的锁");

            }

        }


    }

    @Override
    public void run() {
        try {
            makeup();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

10.生产者和消费者

1.线程通信

在这里插入图片描述

2.分析

在这里插入图片描述

3.线程通信方法概述

在这里插入图片描述

4.解决方案

在这里插入图片描述

1.管道通信代码实现

还未理解

2.信号量代码实现

？

3.线程池

？

curry123456
关注
Java多线程学习笔记(七)--线程池
至尊宝
05-19 2万+
什么是线程池 为了避免系统频繁地创建和销毁线程,我们可以让创建的线程进行复用,线程池是来管理线程的,线程池中总有那么几个活跃线程,当使用线程时可以从池子中随便拿一个空闲线程,当完成工作时,不用立即关闭线程,而是将线程还给线程池,方便下一个要使用线程的任务,有了线程池后,创建线程变成是从线程池中拿线程,销毁线程时变成是将线程还给线程池继续管理。 这种场景非常像在开发中连接数据库,有一个数据库连...
多线程学习笔记05线程协作
asdfghjkl_zth的博客
02-01 2617
文章目录多线程学习笔记05线程协作线程通信解决方式1管程法解决方式2信号灯法 多线程学习笔记05线程协作 线程通信 应用场景：生产者和消费者问题 假设仓库中只能存放一件产品，生产者将生产出来的产品放入仓库，消费者将仓库中产品取走消费； 如果仓库中没有产品，则生产者将产品放入仓库，否则停止生产并等待，直到仓库中的产品被消费者取走为止； 如果仓库中放有产品，则消费者可以将产品取走消费，否则停止消费并等待，直到仓库中再次放入产品为止。 我们来分析一下： 首先，这是一个线程同步问题，生产者和消费者共享同一个资
Java 多线程学习笔记
2301_76962889的博客
07-13 1893
*进程：**是操作系统进行资源分配和调度的基本单位，是程序的一次执行过程。**例如：**当你打开一个应用程序，如浏览器、音乐播放器等，操作系统就会为其创建一个进程。**线程：**是进程的一个执行单元，是 CPU 调度和分派的基本单位，一个进程可以包含多个线程。**例如：**在浏览器进程中，可以有多个线程同时运行，例如一个线程负责页面渲染，另一个线程负责网络请求。提高 CPU 利用率，充分利用多核处理器**例如：**下载软件使用多线程可以同时下载多个文件片段，充分利用带宽，提高下载速度。
Java多线程学习笔记
qq_44903634的博客
08-01 1581
wait()会使“当前线程”等待，因为线程进入等待状态，所以线程应该释放它锁持有的“同步锁”，否则其它线程获取不到该“同步锁”而无法运行！其他线程获取“该对象的同步锁”(
C#多线程学习笔记
wangyunman的博客
08-23 800
C#多线程 1、多线程使用一般方法 Thread t = new Thread(new ThreadStart(Method)); Method为无参函数，若要传递参数，可以将Method的参数设置为object类型。 2、多线程处理List 最近碰到了多线程处理List的问题，开始的想法是开启5个线程，每个线程轮流获取List中的字符串，但是处理完一个字符串就有一个问题，线程无法重用，线程重用可...
Java 多线程学习笔记（狂神）
qq_36188127的博客
11-18 3460
第1章 1.1 什么是线程 栈空间操作起来最快但是栈很小，通常大量的对象都是放在堆空间，栈和堆的大小都可以通过 JVM 的启动参数来进行调整，栈空间用光了会引发 StackOverflowError，而堆和常量池空间不足则会引发 OutOfMemoryError。 String str = new String("hello"); 上面的语句中变量 str 放在栈上，用 new 创建出来的字符串对象放在堆上，而 “hello” 这个字面量是放在方法区的。 1.2 线程的创建与运行 1.2.1 继承 T
多线程基础学习笔记
旋风小陀螺
03-12 1516
多线程基础学习笔记
java多线程学习笔记
weach的博客
12-19 917
java多线程
C++多线程学习笔记（一）
m0_63932570的博客
05-04 2146
今天是五月三号，五一放假五天，博主也就给自己放了三天假，去游山玩水，吃美食。今天是第四天了，也该慢慢找回学习的状态啦。所以今天博主也是改变自己最近懒惰的状态，来开始自己学习多线程的基础知识。多线程这部分内容对于java，c++爱好者应该不陌生，经常听到或看到的吧。建议在学完c++基础语言知识后的同学们，还是值得学一下这部分内容的（其实也不算很多内容）。下面我们正式开始来看看吧 1.理解多线程。 多线程并发指的是在同一个进程中执行多个线程。C++11提供了语言层面上的多线程，包含在头文件<threa
JAVA 多线程学习笔记
03-27
这篇学习笔记将深入探讨Java多线程的核心概念、实现方式以及相关工具的使用。 一、多线程基础 1. 线程与进程：在操作系统中，进程是资源分配的基本单位，而线程是程序执行的基本单位。每个进程至少有一个主线程，...
java多线程学习笔记之自定义线程池
08-29
Java多线程学习笔记之自定义线程池 本篇文章主要介绍了Java多线程学习笔记之自定义线程池，通过深入了解ThreadPoolExecutor这个核心类，我们可以自定义线程池，满足不同的线程池需求。 Java多线程学习笔记之自定义...
多线程学习笔记.docx
06-16
在多线程编程中，进程和线程是两个核心概念。进程是操作系统资源分配的基本单位，每个独立执行的程序都对应一个进程。而线程则是程序执行的最小单元，是进程内部的一条执行路径。多线程是指在一个应用程序中存在多个...
多线程 学习笔记.md
05-04
多线程 学习笔记.md
JDK1.0主要特性
最新发布
FoolRabbit的专栏
10-06 243
JDK1.0主要特性。
JavaScript ArrayBuffer的读写与类型转换
白瑕 的博客
10-01 471
所有视图的基本单位是ArrayBuffer, ArrayBuffer中只存储二进制格式的数据.ArrayBuffer不可直接读写, 必须通过视图(比如DataView)暴露的API.
java将word转pdf
紫月7575的博客
09-30 568
java将word转pdf
spring-boot 整合 mybatis
m0_72168501的博客
09-29 569
spring boot 整合 mybatis
多线程学习笔记：概念与初步实践
"关于多线程学习总结" 在计算机科学中，多线程是并发执行的编程模型，允许程序在同一时间处理多个任务。这种技术尤其在需要优化资源利用和提高响应速度的应用中至关重要。多线程使得程序员能够在一个进程中创建多个...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值