2021-08-27

最新推荐文章于 2022-07-26 10:39:42 发布
最新推荐文章于 2022-07-26 10:39:42 发布
阅读量107 收藏
点赞数
分类专栏： 笔记 文章标签： java rust elasticsearch
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_47237102/article/details/119961436
版权

进程和线程
在这里插入图片描述
实现多线程
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

package Thread00;

public class MyThreadDemo {
    public static void main(String[] args) {
        MyThread my1=new MyThread();
        MyThread my2=new MyThread();
        my1.run();//错误
        my2.run();//错误，应该调用start()方法
        my1.start();//导致线程开始执行，java虚拟机调用此线程的run方法
        my2.start();
    }
}


package Thread00;
//定义一个MyThread类继承Thrad类
public class MyThread extends Thread {
    //重写Thread类的run方法
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println(i);
        }
    }
}

设置和获取线程名称
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

package Thread00;

public class MyThreadDemo {
    public static void main(String[] args) {
        //使用的是无参构造方法
//        MyThread my1=new MyThread();
//        MyThread my2=new MyThread();
//        my1.run();//错误
//        my2.run();//错误，应该调用start()方法
//        my1.start();//导致线程开始执行，java虚拟机调用此线程的run方法
//        //void steName(String name)
//        my1.setName("高铁");
//        my2.setName("飞机");
        //Thread(String Name)
          MyThread my1=new MyThread("高铁");
          MyThread my2=new MyThread("飞机");
        System.out.println(Thread.currentThread().getName());
        my1.start();
        my2.start();
    }
}

线程优先级
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

package Thread00;

public class ThreadPriority extends Thread{
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println(getName() + ":" + i);
        }
    }
}

package Thread00;

public class ThreadPriorityDemo {
    public static void main(String[] args) {
        ThreadPriority tp1=new ThreadPriority();
        ThreadPriority tp2=new ThreadPriority();
        ThreadPriority tp3=new ThreadPriority();
        tp1.setName("高铁");
        tp2.setName("飞机");
        tp3.setName("汽车");
        System.out.println(tp1.getPriority());//5线程默认优先级是5
        System.out.println(tp2.getPriority());
        System.out.println(tp3.getPriority());

        //设置优先级： public final void setPriority(int newPriority)
        System.out.println(Thread.MAX_PRIORITY);//10
        System.out.println(Thread.MIN_PRIORITY);//1
        System.out.println(Thread.NORM_PRIORITY);//5
        tp1.setPriority(5);
        tp2.setPriority(10);
        tp3.setPriority(1);
        tp1.start();
        tp2.start();
        tp3.start();

    }
}

线程控制
在这里插入图片描述
睡眠线程

package Thread00;

public class ThreadSleep extends Thread{
    @Override
    public void run() {
        for (int i=0;i<100;i++){
            System.out.println(getName()+":"+i);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}


package Thread00;
//static void sleep(long millis)毫秒

public class ThreadSleepDemo {
    public static void main(String[] args) {
        ThreadSleep ts1=new ThreadSleep();
        ThreadSleep ts2=new ThreadSleep();
        ThreadSleep ts3=new ThreadSleep();
        ts1.setName("1");
        ts2.setName("2");
        ts3.setName("3");
        ts1.start();
        ts2.start();
        ts3.start();
    }
}

等待死亡线程


package Thread00;

public class Threadjoin extends Thread{
    @Override
    public void run() {
       for (int i=0;i<100;i++){
           System.out.println(getName()+":"+i);
       }
    }
}


package Thread00;

import java.io.IOException;
//void join()等待这个线程死亡

public class ThreaJoinDemo {
    public static void main(String[] args) throws InterruptedException {
        Threadjoin tj1=new Threadjoin();
        Threadjoin tj2=new Threadjoin();
        Threadjoin tj3=new Threadjoin();
        tj1.setName("杨幂");
        tj2.setName("超越");
        tj3.setName("白鹿");
        tj1.start();
        try {
            tj1.join();
        }catch (InterruptedException e){
            e.printStackTrace();
        }
        tj2.start();
        tj3.start();
    }
}

守护线程

package Thread00;

public class ThreadDaemon extends Thread{
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println(getName() + ":" + i);
        }
    }
}


package Thread00;
//void setDaemoDemo(boolean on):将此线程标记为守护线程，当运行的线程都是守护线程是，JVM虚拟机将退出
public class ThreaDaemoDemo {
    public static void main(String[] args) {
        ThreadDaemon td1=new ThreadDaemon();
        ThreadDaemon td2=new ThreadDaemon();
        ThreadDaemon td3=new ThreadDaemon();
        td1.setName("林一");
        td2.setName("小鬼");
        //设置主线程为刘备
        Thread.currentThread().setName("李钟硕");
        //设置守护线程
        td1.setDaemon(true);
        td2.setDaemon(true);
        td1.start();
        td2.start();

        for (int i=0;i<10;i++){
            System.out.println(Thread.currentThread().getName()+":"+i);
        }
    }
}

线程生命周期
在这里插入图片描述
多线程的实现方式
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

package Thread00;

public class MyRunnable implements Runnable {
    @Override
    public void run() {
        for (int i=0;i<100;i++){
            System.out.println(Thread.currentThread().getName()+":"+i);//不能直接使用getName方法，因为没有继承Thread类
        }
    }
}


package Thread00;

public class MyRunnableDemo {
    public static void main(String[] args) {
        MyRunnable my=new MyRunnable();
        
        //创建Thread类的对象，把Runnable对象作为构造方法的参数
        //Thread(Runnable target)
//        Thread t1=new Thread(my);
//        Thread t2=new Thread(my);
       //Thread(Runnable target,String name)
        Thread t1=new Thread(my,"高铁");
        Thread t2=new Thread("飞机");
        //启动线程
        t1.start();
        t2.start();
        
    }
}

卖票案例
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
卖票案例的思考
在这里插入图片描述
出现了负数的票
在这里插入图片描述
相同的票出现了多次
在这里插入图片描述
解决办法
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
同步方法解决数据安全问题
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

package Thread00;

public class SellTicket implements Runnable {
    private int tickets = 100;
    private Object obj=new Object();//一定要是同一个对象，这样才是一把锁

    @Override
    public void run() {
        while (true) {  //死循环让卖票的动作一直执行
            synchronized(obj) {
                if (tickets > 0) {
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + "正在出售第" + tickets + "张票");
                    tickets--;
                }
            }
        }
    }
}


package Thread00;

public class SellTicketDemo {
    public static void main(String[] args) {
        SellTicket s1=new SellTicket();
        Thread t1=new Thread(s1,"窗口1");
        Thread t2=new Thread(s1,"窗口2");
        Thread t3=new Thread(s1,"窗口3");

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

同步方法
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

package Thread00;

public class SellTicket implements Runnable {
    private int tickets = 100;
    private Object obj=new Object();//一定要是同一个对象，这样才是一把锁
    private int x=0;

    @Override
    public void run() {
        while (true) {  //死循环让卖票的动作一直执行
            if (x % 2 == 0) {
                //synchronized (obj) {
                    synchronized (this) {
                    if (tickets > 0) {
                        try {
                            Thread.sleep(100);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        System.out.println(Thread.currentThread().getName() + "正在出售第" + tickets + "张票");
                        tickets--;
                    }
                }
            }else {
//                private synchronized void sellticket(){
//                    if (tickets > 0) {
//                        try {
//                            Thread.sleep(100);
//                        } catch (InterruptedException e) {
//                            e.printStackTrace();
//                        }
//                        System.out.println(Thread.currentThread().getName() + "正在出售第" + tickets + "张票");
//                        tickets--;
//                    }
//                }
                sellticket();
            }
            x++;
        }
        }

    private synchronized void sellticket() {
        if (tickets > 0) {
                        try {
                            Thread.sleep(100);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        System.out.println(Thread.currentThread().getName() + "正在出售第" + tickets + "张票");
                        tickets--;
        }
    }
}



package Thread00;

public class SellTicketDemo {
    public static void main(String[] args) {
        SellTicket s1=new SellTicket();
        Thread t1=new Thread(s1,"窗口1");
        Thread t2=new Thread(s1,"窗口2");
        Thread t3=new Thread(s1,"窗口3");

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

同步静态方法

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

package Thread00;

public class SellTicket implements Runnable {
    private static int tickets = 100;
    private Object obj=new Object();//一定要是同一个对象，这样才是一把锁
    private int x=0;

    @Override
    public void run() {
        while (true) {  //死循环让卖票的动作一直执行
            if (x % 2 == 0) {
                //synchronized (obj) {
                    synchronized (SellTicket.class) {
                    if (tickets > 0) {
                        try {
                            Thread.sleep(100);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        System.out.println(Thread.currentThread().getName() + "正在出售第" + tickets + "张票");
                        tickets--;
                    }
                }
            }else {
//                private synchronized void sellticket(){
//                    if (tickets > 0) {
//                        try {
//                            Thread.sleep(100);
//                        } catch (InterruptedException e) {
//                            e.printStackTrace();
//                        }
//                        System.out.println(Thread.currentThread().getName() + "正在出售第" + tickets + "张票");
//                        tickets--;
//                    }
//                }
                sellticket();
            }
            x++;
        }
        }

    private static synchronized void sellticket() {
        if (tickets > 0) {
                        try {
                            Thread.sleep(100);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        System.out.println(Thread.currentThread().getName() + "正在出售第" + tickets + "张票");
                        tickets--;
        }
    }
}

线程安全的类
在这里插入图片描述
在这里插入图片描述
Lock锁
在这里插入图片描述
在这里插入图片描述

package Thread00;

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class Selltickets01 implements Runnable{
    private int tickets=100;
    private Lock lock=new ReentrantLock();
    @Override
    public void run() {
        while (true) {
            try {
                lock.lock();
                if (tickets > 0) {
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + "正在出售第" + tickets + "张票");
                    tickets--;
                }
            }finally {
                lock.unlock();
            }
        }
    }
}


package Thread00;

public class SellticketsDemo01 {
    public static void main(String[] args) {
        SellTicket s1=new SellTicket();
        Thread t1=new Thread(s1,"窗口1");
        Thread t2=new Thread(s1,"窗口2");
        Thread t3=new Thread(s1,"窗口3");
        t1.start();
        t2.start();
        t3.start();
    }
}

生产者和消费者模式概述

在这里插入图片描述
在这里插入图片描述
生产者和消费者案例
在这里插入图片描述
奶箱类
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

package Thread00;

public class Box {
    //定义一个变量，表示第x瓶奶
    private int milk;
    //提供存取牛奶和获取牛奶的方法
    //定义一个成员变量,表示奶箱的状态,默认情况下是没有牛奶的
    private boolean state=false;
    public synchronized void put(int milk) {
        //如果有牛奶，等待消费者消费
        if (state){
            System.out.println("状态:"+state);//true
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        //如果没有牛奶，就生产牛奶
        this.milk=milk;
        System.out.println("送奶工将第"+milk+"瓶奶放入奶箱");
        System.out.println("状态:"+state);//false
        //生产完毕后，修改奶箱状态；
        state=true;
        //唤醒其他等待的线程
        notifyAll();
    }
    public synchronized void get(){
        //如果没有牛奶，等待生产
        if (!state){
            System.out.println("状态:"+state);//false
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        //如果有牛奶，消费牛奶
        System.out.println("顾客拿到第"+milk+"瓶奶");
        //消费完毕后，更改奶箱状态
        state=false;
        //唤醒其他等待的线程
        notifyAll();
    }
}

消费者类

在这里插入图片描述

package Thread00;

public class Customer implements Runnable{
    private Box b;
    public Customer(Box b) {
        this.b=b;
    }

    @Override
    public void run() {
        while (true){
            b.get();
        }
    }
}

生产者类
在这里插入图片描述

package Thread00;

public class Producer implements Runnable{
    private Box b;
    public Producer(Box b) {
        this.b=b;

    }
    @Override
    public void run() {
        for (int i=1;i<=5;i++) {
            b.put(i);
        }
    }
}

测试类
在这里插入图片描述
在这里插入图片描述

package Thread00;

public class BoxDemo {
    public static void main(String[] args) {
        Box b=new Box();
        Producer p=new Producer(b);
        Customer c=new Customer(b);
        Thread t1=new Thread(p);
        Thread t2=new Thread(c);
        t1.start();
        t2.start();
    }
}
qq_47237102
关注
专栏目录
使用多线程实现两个子线程分别对1~100的奇偶输出
mumihahaha的博客
03-15 744
方法一：创建两个对象实现package com.atguigu.thread.exer; class SubThread1 extends Thread{ public void run(){ for (int i = 1; i &lt;= 100; i++) { if (i%2==0) { System.out.println(currentThread().getName...
千锋教育—Kafka—2021-08-27
张老师的博客
03-06 1153
视频链接 一.：（～） 1：：    1）：     -1：：     -2：：     -3：：     -4：：     -5：：    2）：     -1：：     -2：：     -3：：     -4：：     -5：：    3）：     -1：：     -2：：     -3：：     -4：：     -5：：    4）：     -1：：     -2：：     -3：：     -4：：     -5：：    5）：     -1：：     -
创建线程，Thread类常用方法，线程状态，线程安全问题
xaiobit_hl的博客
07-26 2879
认识线程，Thread类常用方法，线程状态，线程安全问题
Java多线程基础知识学习笔记
TIANJIAWEN的博客
03-10 371
写在前面:马上秋招，打算从0开始再学一遍Java，开个知识点记录贴，就当做课堂笔记吧. 希望秋招顺利. 程序、进程、线程 1.程序(program)是为完成特定任务、用某种语言编写的一组指令的集合.即指一段静态的代码,静态对象 2.进程(process)是程序的一次执行过程，或是正在运行的一个程序，是一个动态的过程:有它自身的产生、存在和消亡的过程.------生命周期 ·如：运行中的微信、运行中的mp3播放器 ......
Java基础（24）之多线程
笑笑不说话
03-21 184
1. 实现多线程 1.1 进程 1.2 线程 1.3 多线程的实现方式 代码示例： 定义类MyThread： //1:定义一个类MyThread继承Thread类 public class MyThread extends Thread { // 2:在MyThread类中重写run()方法 // 为什么要重写run方法，是因为在类中，并不是所有代码都需要执行多线程的， // 所有就...
Java学习day022-025(多线程-B站黑马版)
牢骚太盛防肠断，风物长宜放眼量
08-22 120
文章目录1.进程和线程2.继承Thread类的方式实现多线程3.设置和获取线程名称4.线程优先级5.线程控制6.线程的生命周期7.实现Runnable接口8.卖票9.卖票案例的思考10.同步代码块解决数据安全问题11.同步方法解决数据安全问题12.线程安全的类13.Lock锁14.生产者消费者模式15.生产者消费者案例 1.进程和线程 进程 进程：是正在运行的程序 是系统进行资源分配和调用的独立单位 每一个进程都有它自己的内存空间和系统资源 线程 线程:是进程中 的单个顺序控制流,是一条执行路径 单线
2021-07-18 Debug
Choulongx的博客
07-18 490
今天发现了一个低级错误 [Error] ld returned 1 exit status 回去查发现是写错了主函数名称 我是sb
2021-08-19
lyl455133的博客
08-19 2609
Vivado连接不上仿真器 欢迎使用Markdown编辑器 Vivado连接仿真器时，出现错误如下： [Labtools 27-2223] Unable to connect to hw_server with URL “TCP:localhost:3121”. 解决方法： 安装Vivado的JTAG驱动。JTAG驱动在Vivado安装目录X:\Xilinx\Vivado\2015.4\data\xicom\cable_drivers\nt64\digilent\， 双击install_digilent.e
jzrecord_2021-08-27 16：03：52.mp4
08-27
学生
python密码破解2021-08-27
fanZhenFang123的博客
04-28 252
排列 import itertools #排列：从n个不同元素中取出m（m≤n）个元素，按照一定的顺序排成一列，叫做从n个元素中取出m个元素的一个排列(permutation)。特别地，当m=n时，这个排列被称作全排列(all permutation)。 ''' 1 2 3 4 ''' myList = list(itertools.permutations([1,2,3,4], 4)) print(myList) print(len(myList)) ''' 4-3 24 4-2 12 4-1 排列
2021-08-27 乌班图安装GCC
JarKuo的博客
08-27 1159
乌班图安装GCC 第一步： sudo apt update 第二步： sudo apt install build-essential 出现的问题： 出现了 Media change : please insert the disc 取消当前安装 ctrl + c 使用pwd命令查看当前所在目录，需要进入 \etc\apt 目录下的 sources.list 文件将 cdrom 注释掉 我使用的是乌班图版本是20.1，sources.list文件默认是锁定的无法修改，需要在前面加上sudo。 sudo
关于 public static void main(String[] args) {...}
choushe1877的博客
04-21 1196
public static void main(String[] args) 这绝对不是凭空想出来的，也不是没有道理的死规定，而是java程序执行的需要。 jvm在试图运行一个类之前，先检查该类是否包含一个特殊方法。 这个方法必须是公有的，以便在任何位置都能访问得到。 这个方法必须是s...
HTML+CSS实战：做一个京东登录页面
热门推荐
qq_47237102的博客
09-19 1万+
首先创建一个HTML目录,在目录下创建一个html文件，一个index.css文件，一个base.css文件 然后在html中写页面的相关代码，主要分为三个部分：顶部，主体和尾部 同时不要忘了在目录下创建一个文件夹放要·用到的·图片 顶部(top)内容包括 logo部分： 字体“欢迎登录部分” 2.主体(main)内容包括： 中间区域的主体 居中的主体区域 登录的白色登录区域(分login（登录）,input(文本框)，auto-login(自动登录），超链接a标签（忘记密码)，sub...
Java图书馆管理系统
qq_47237102的博客
09-12 5423
package BookBorrow; import java.util.HashMap; import java.util.Map; import java.util.Scanner; //图书入口 public class BookEntrance { //用来保存我们整个图书馆有的书籍 static Book[] books = new Book[200]; //保存书籍和借阅人的关系 static Map<String ,Book> link=new .
Collection、List、Set、ArrayList、LinkedList、HashSet、TreeSet
qq_47237102的博客
09-04 252
集合Collection 默认返回true List集合概述和特点 List存储学生对象并遍历 package Collection; public class Student { private String name; private int age; public Student(String name, int age) { ...
2021-06-20
qq_47237102的博客
06-20 124
类和对象 1.类：是抽象的概念集合，表示的是一个共性的产物，类之中定义的是属性和行为（方法）； 2.对象：对象是一种个性的表示，表示一个独立的个体，每个对象拥有自己独立的属性，依靠属性来区分不同对象。万物皆对象，客观存在的事物皆为对象。 3.面向对象： 面向对象是一种思想，是基于面向过程而言的，就是说面向对象是将功能等通过对象来实现，将功能封装进对象之中，让对象去实现具体的细节；这种思想是将数据作为第一位，而方法或者说是算法作为其次，这是对数据一种优化，操作起来更加的方便，简化了过程。 4.类的定
Servlet笔记
qq_47237102的博客
09-24 116
创建一个Servlet 新建一个包，在包下建一个java类，在右击建一个Servlet类 Servlet生命周期的两种方式： 1.从第一次调用到服务器关闭 2.在对应的Servlet配置文件中配置load-on-startup，到服务器关闭（第二种方法） ...
没有囊括2021-10-31 20:09:33.407和2018-08-25 10:27:42.0 请重写，并详细解释
最新发布
07-14
非常抱歉给你带来了困惑。以下是一个修正后的SQL正则表达式，可以匹配'YYYY-MM-DD HH:mm:ss.sss'格式的日期： ```sql SELECT * FROM your_table WHERE your_column REGEXP '^(19|20)\d{2}-(0[1-9]|1[0-2])-(0[1-9]|...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值