第十九天学习笔记

已于 2023-10-22 15:41:44 修改
阅读量45 收藏
点赞数
文章标签： 学习 笔记
于 2023-10-22 15:40:03 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/CMBSNBB/article/details/133949697
版权

多线程

1.第一种方式实现

 //这是第一种方式，继承Thread类
/*      ThreadOne tOne = new ThreadOne();
        ThreadOne tTwo = new ThreadOne();
        tOne.setName("线程1");
        tTwo.setName("线程2");
        tOne.start();
        tTwo.start();*/

class ThreadOne extends  Thread{
    @Override
    public void run(){
        for (int i = 0; i < 100; i++) {
            System.out.println("这是线程"+this.getName());
        }
    }
}

2.第二种方式实现

        //这是第二种方式，实现接口方法
/*     ThreadTwo ttOne = new ThreadTwo();
       ThreadTwo ttTwo = new ThreadTwo();
       Thread tOne = new Thread(ttOne);
       Thread tTwo = new Thread(ttTwo);
       tOne.setName("线程1");
       tTwo.setName("线程2");
       tOne.start();
       tTwo.start();*/
class  ThreadTwo implements Runnable{

    @Override
    public void run( ) {
        for (int i = 0; i < 100; i++) {
            //因为不是继承类，所以无法通过getName去获得线程名字，Thread是一个类，所以自带静态方法。
            //关注Api帮助文档，给你带来更多快乐
            Thread thread = Thread.currentThread();
            System.out.println("这是线程"+thread.getName());
        }
    }
}

3.第三种方式实现

class MyThread implements Callable<Integer>{
    @Override
    public Integer call() throws Exception {
        int sum=0;
        for (int i = 0; i <= 100; i++) {
            sum = sum+i;
        }
        return sum;
    }
}

 //这是第三种方法，实现futureTask

    //创建一个类实现Callable对象，表示要执行的任务
    MyThread mt = new MyThread();
    //创建线程管理对象
    FutureTask<Integer> ft = new FutureTask<>(mt);
    //创建线程
    Thread thread = new Thread(ft);
    //线程启动
    thread.start();
    //通过ft.get() 得到线程运行结果
    System.out.println(ft.get());

}

4.方法：

补充：子类要实现父类构造方法，这样才能通过构造方法去设置名称。

线程：

ThreadOne tOne = new ThreadOne("线程一");
ThreadOne tTwo = new ThreadOne("线程贰");
//设置线程的优先级，优先级越高，则抢夺CPU的概率越高，默认为5
tOne.setPriority(1);
tTwo.setPriority(8);

System.out.println(tOne.getPriority());
System.out.println(tTwo.getPriority());

tOne.start();
tTwo.start();

守护线程代码和场景：

yield（）：让出线程，让出后再竞争，尽可能均匀一点，但是不一定。

Join插入线程:

线程周期：

线程互斥问题:通过卖电影票实现   synchronized：称为同步代码块

//以下是互斥代码
Moive moive1 = new Moive("1");
Moive moive2 = new Moive("贰");
Moive moive3 = new Moive("三");

moive1.start();
moive2.start();
moive3.start();
class Moive extends  Thread{
    static int count = 1;
    public Moive() {
    }

    public Moive(String name) {
        super(name);
    }
    //定义一个全局变量，但是需要加一个 static 关键字，这样不管创建多少个对象都表示使用一个变量
    //为了互斥买票且不出现多卖的情况，必须加锁，锁对象任意，但必须唯一，一般用  类名.class
    @Override
    public void run()  {
        //互斥
        //标红两句代码不能写反，否则一直是一个进程运行
         while(count<=100){
             synchronized (Moive.class){
             Thread thread = Thread.currentThread();
             try {
                 thread.sleep(100);
             } catch (InterruptedException e) {
                 throw new RuntimeException(e);
             }
             System.out.println(this.getName()+"售卖第"+count+"张票");
             count++;
         }
      }
   }
}

synchronized：同步代码块详解

 //以下是互斥代码,第二种实现方式
MoiveTwo moive = new MoiveTwo();
Thread thread1 = new Thread(moive);
Thread thread2 = new Thread(moive);
Thread thread3 = new Thread(moive);

thread1.setName("刘一手");
thread2.setName("王二狗");
thread3.setName("张三");

thread1.start();
thread2.start();
thread3.start();


class Moive extends  Thread{
    static int count = 1;
    public Moive() {
    }

    public Moive(String name) {
        super(name);
    }
    //定义一个全局变量，但是需要加一个 static 关键字，这样不管创建多少个对象都表示使用一个变量
    //为了互斥买票且不出现多卖的情况，必须加锁，锁对象任意，但必须唯一，一般用  类名.class
    @Override
    public void run()  {
        //互斥

         while(count<=100){
             synchronized (Moive.class){
             Thread thread = Thread.currentThread();
             try {
                 thread.sleep(100);
             } catch (InterruptedException e) {
                 throw new RuntimeException(e);
             }
             System.out.println(this.getName()+"售卖第"+count+"张票");
             count++;
         }
     }


    }



}
//这是线程方法学习第二种实现，将锁代码的方法提取出来。

class  MoiveTwo implements   Runnable{
     int count = 1;

    //定义一个全局变量，但是需要加一个 static 关键字，这样不管创建多少个对象都表示使用一个变量
    //为了互斥买票且不出现多卖的情况，必须加锁，锁对象任意，但必须唯一，一般用  类名.class
//但是这种情况下，类只会生成一个对象，所以可以不用Static，还有，这样代码运行会有问题，当count==100的时候，其他两个线程还会增加，所以还是的判断count>100;则直接退出

//继承Thread类的那种生成方式不能用这种提取方法：因为无法指定对象去锁定，所以无法用此方法
    @Override
    public void run()  {
        //互斥

        while(count<=100){

                setCount();
        }
    }

    private synchronized void setCount() {
        Thread thread = Thread.currentThread();
        try {
            thread.sleep(100);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        System.out.println( thread.getName()+"售卖第"+count+"张票");
        count++;
    }


}

stringBuffer  和 stringBuilder   :用法一样，但是前者考虑了线程安全问题。

5.提取代码块成为方法：ctrl+alt+m

6.ctrl+alt+T,补充很多好东西

7. Lock锁

代码

MoiveThree moive1 = new MoiveThree("1");
MoiveThree moive2 = new MoiveThree("贰");
MoiveThree moive3 = new MoiveThree("三");

moive1.start();
moive2.start();
moive3.start();

class MoiveThree extends  Thread{
    Thread thread = Thread.currentThread();
    static ReentrantLock lock = new ReentrantLock();

    static int count = 0;
public MoiveThree() {
        }

public MoiveThree(String name) {
        super(name);
        }
//定义一个全局变量，但是需要加一个 static 关键字，这样不管创建多少个对象都表示使用一个变量
//为了互斥买票且不出现多卖的情况，必须加锁，锁对象任意，但必须唯一，一般用  类名.class
@Override
public void run()  {
        //互斥
    while(true){



            lock.lock();

        try {
            if(count ==100){
            return;
        }

            thread.sleep(100);
            count++;
            System.out.println(this.getName()+"售卖第"+count+"张票");
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        } finally {
            lock.unlock();
        }

    }
 }
}

8.生产者和消费者

注意点：加锁家的是同一把，不是给线程加锁。

public class ThreadWaitStudy {
   public static int tableState =1;
    public  static int eatCount = 10;

    public static  Object obj = new Object();

    public static void main(String[] args) {

    Client client = new Client("客人");
    Chef     chef = new Chef("厨师");
        client.start();
        chef.start();

    }
}

//客人类
class Client extends Thread{
    public Client() {
    }

    public Client(String name) {
        super(name);
    }

    @Override
    public void run(){

        while (true){

            synchronized (ThreadWaitStudy.obj){
                if(ThreadWaitStudy.eatCount ==0){
                    break;
                }else {
                    if (ThreadWaitStudy.tableState == 0) {
                        System.out.println("没面了，别吃了");
                        try {
                            ThreadWaitStudy.obj.wait();
                        } catch (InterruptedException e) {
                            throw new RuntimeException(e);
                        }

                    } else {

                        ThreadWaitStudy.eatCount--;
                        System.out.println(currentThread().getName() + "还能吃" + ThreadWaitStudy.eatCount + "碗");
                        ThreadWaitStudy.obj.notify();
                        ThreadWaitStudy.tableState = 0;
                    }
                  }
                }
            }
        }
    }

//厨师类
class Chef extends Thread{
    public Chef() {
    }

    public Chef(String name) {
        super(name);
    }

    @Override
    public void run(){

        while (true){
            synchronized (ThreadWaitStudy.obj){
                if(ThreadWaitStudy.eatCount == 0){
                    break;
                }
                else {
                    if(ThreadWaitStudy.tableState == 1) {
                        try {
                            ThreadWaitStudy.obj.wait();
                        } catch (InterruptedException e) {
                            throw new RuntimeException(e);
                        }

                    }
                    else {
                        System.out.println(currentThread().getName() + "做好了面，快吃面");
                        ThreadWaitStudy.obj.notify();
                        ThreadWaitStudy.tableState = 1;
                    }
                }
            }
        }
    }
}

9.阻塞队列：定义队列，通过阻塞队列传值，应该也可以通过公共队列，这里没试过。

import java.util.concurrent.ArrayBlockingQueue;

public class ThreadQueueStudy {
    public static void main(String[] args) {
        //定义阻塞队列的长度
        ArrayBlockingQueue<String> queue = new ArrayBlockingQueue<>(100);
        ClientOne clientOne = new ClientOne(queue);
        ChefOne chefOne = new ChefOne(queue);

        clientOne.start();
        chefOne.start();



    }
}
class ChefOne extends Thread{
    ArrayBlockingQueue<String> queue;
    //通过构造装入值
    public ChefOne(ArrayBlockingQueue<String> queue) {
        this.queue = queue;
    }
   @Override
   public void run() {
        while (true) {
            try {
                queue.add("面条");
            } catch (Exception e) {
               e.printStackTrace();
            }
            System.out.println("..........");
        }
    }
}
//客人类
class ClientOne extends Thread {
    ArrayBlockingQueue<String> queue;

    //通过构造装入值
    public ClientOne(ArrayBlockingQueue<String> queue) {
        this.queue = queue;
    }

    @Override
    public void run() {
        while (true) {
            try {
                System.out.println(queue.take());
            } catch (InterruptedException e) {
               e.printStackTrace();
            }

        }
    }
}

10.线程里面要用集合

改进：集合写在run方法里，这样只需写一次。

11.线程池

实现必须用Runable接口类，否则好像管理不了。

代码：

任务执行顺序：

线程池  ----满了以后---->等待队列  ----满了以后----->临时线程 ----满了以后--->丢弃任务

代码：

//自定义创建
ThreadPoolExecutor executors = new ThreadPoolExecutor(
         3,
         6,
         90,
         TimeUnit.SECONDS,
         new ArrayBlockingQueue<>(3),
         Executors.defaultThreadFactory(),
         new ThreadPoolExecutor.AbortPolicy()
 );
 PoolClass poolClass1 = new PoolClass();
 PoolClass poolClass2 = new PoolClass();
 PoolClass poolClass3 = new PoolClass();
 PoolClass poolClass4 = new PoolClass();

 executors.submit(poolClass1);
 executors.submit(poolClass2);
 executors.submit(poolClass3);
 executors.submit(poolClass4);

12.制定合适线程池大小，没听懂

//获得电脑运行的最大线程数，方便定义线程池。

int systemThread = Runtime.getRuntime().availableProcessors(); System.out.println(systemThread);

13.其他知识点在资料中

CMBSNBB
关注
JAVA学习笔记第九、十、十一天——飞机大战
07-25
在第九、十、十一天的学习笔记中，我们将重点关注如何构建和使用这些核心概念，以及它们在实际编程中的应用。 首先，类是JAVA面向对象编程的基础，它是对象的蓝图或模板。在"飞机大战"的实现中，我们可以创建多个类...
Go 学习笔记 高清
02-03
- 第19章 sync：介绍Locker、Cond、Once、WaitGroup和atomic。 - 第20章 os：包含System、Environ、Process、Signal和User。 第三部分：扩展库 - 提到了mgo（MongoDB的Go语言驱动）和RichMON（网络监控工具）。 从...
数据结构——学习笔记——入门必看【建议收藏】
热门推荐
刘鑫磊
02-09 44万+
（2）静态查找表&动态查找表的区别用法【顺序查找-线性查找-折半查找-二分查找-有序表查找-插值查找-斐波那契查找-索引顺序表查找-分块查找】单独使用顺序存储结构（即数组）无法很好地实现树的存储概念，不过如果充分利用顺序存储和链式存储结构的特点，则完全可以实现对数的存储结构的表示。深度为 2，则至多只有 3 个结点：根结点，根结点的左子树，根结点的右子树···指的是这样一个数列：1、1、2、3、5、8、13、21、……（3）四中常见的多路查找树【2-3 树$2-3-4 树$B 树$B+ 树】的区别用法。
前端学习笔记202309学习笔记第九十天-闭包
qq_41632427的博客
09-15 89
前端
前端学习笔记202309学习笔记第九十三天-原型19
qq_41632427的博客
09-20 71
前端
Python学习笔记第二十九天
qq_43239716的博客
07-24 241
GAN
前端学习笔记202309学习笔记第九十天-闭包10
qq_41632427的博客
09-16 96
前端
前端学习笔记202309学习笔记第九十天-闭包9
qq_41632427的博客
09-15 95
前端
前端学习笔记202309学习笔记第九十天-闭包14
qq_41632427的博客
09-16 81
前端
前端学习笔记202309学习笔记第九十天-闭包11
qq_41632427的博客
09-16 77
前端
前端学习笔记202309学习笔记第九十天-闭包7
qq_41632427的博客
09-15 74
前端
前端学习笔记202309学习笔记第九十天-闭包6
qq_41632427的博客
09-15 74
前端
原创-RHCE学习笔记 11年4月20日 第十九天 iptables防火墙.docx
10-31
原创-RHCE学习笔记 11年4月20日 第十九天 iptables防火墙.docx
PS基础第八天笔记 PS基础第八天笔记
03-10
### PS基础第八天笔记知识点详解 #### 一、滤镜认识 **PS滤镜**是Photoshop中的一个重要功能，主要用于实现图像的各种特殊效果。通过不同的滤镜命令，用户可以创造出丰富的视觉效果。 - **智能滤镜** - 定义：...
MyBatis-Plus 学习笔记.pdf
08-30
MyBatis-Plus 学习笔记 MyBatis-Plus 是一个基于 MyBatis 的增强工具，旨在简化开发、提高效率。它提供了许多实用的特性和功能，例如无侵入、损耗小、强大的 CRUD 操作、支持 Lambda 形式调用、支持多种数据库、...
ORB-SLAM2源码学习：ORBextractor.cc：IC_Angle 利用灰度质心法求解关键点方向角
2301_76831056的博客
11-01 701
IC_Angle 利用灰度质心法求解关键点方向角并在computeOrientation函数中被调用计算图像中所有特征点的方向。
嵌入式通信协议：MODBUS简明学习笔记
weixin_73867577的博客
11-02 353
学习Modbus的简明学习笔记
软件测试学习笔记丨Vue常用指令-条件渲染（v-if）
最新发布
ceshiren_com的博客
11-05 498
v-show只是简单控制dom元素的display属性。v-if通过操纵dom元素来进行切换显示。
SPI通信详解-学习笔记
qq_45059758的博客
11-04 505
SPI通信
Effective C++第三版学习笔记
"Effective_C++_3rd笔记.pdf" 这篇读书笔记是基于《Effective C++ Third Edition》这本书，作者是吴金龙，来自北京大学数学科学学院。笔记内容涵盖了C++编程中的最佳实践和优化技巧，旨在帮助读者更好地理解和利用...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值