黑马程序员——javase进阶——day09——线程安全,死锁,状态,通讯,线程池

目录：

  1. 线程安全
    1. 线程安全产生的原因
    2. 线程的同步
    3. 同步代码块
    4. 同步方法
    5. Lock锁
  2. 线程死锁
    1. 概述:
    2. 产生条件:
    3. 代码实践
  3. 线程的状态
  4. 线程通信
  5. 线程池
    1. 线程使用存在的问题
    2. 线程池的介绍
    3. 线程池使用的大致流程
    4. 线程池的好处
    5. Java提供好的线程池
    6. 线程池处理Runnable任务
    7. 线程池处理Callable任务

1.线程安全

线程安全产生的原因

  • 多个线程在对共享数据进行读改写的时候，可能导致的数据错乱就是线程的安全问题了

package com.itheima.ticket_demo;/*电影院*/
public class Ticket implements Runnable {private int ticketCount = 100; // 一共有一百张票@Overridepublic void run() {while (true) {// 如果票的数量为0 , 那么停止买票if (ticketCount == 0) {break;} else {// 有剩余的票 , 开始卖票ticketCount--;System.out.println(Thread.currentThread().getName() + "卖出一张票,剩下" + ticketCount + "张");}}}
}

package com.itheima.ticket_demo;/*1 定义一个类Ticket实现Runnable接口，里面定义一个成员变量：private int ticketCount = 100;2 在Ticket类中重写run()方法实现卖票，代码步骤如下A：判断票数大于0，就卖票，并告知是哪个窗口卖的B：票数要减1C：卖光之后，线程停止3 定义一个测试类TicketDemo，里面有main方法，代码步骤如下A：创建Ticket类的对象B：创建三个Thread类的对象，把Ticket对象作为构造方法的参数，并给出对应的窗口名称C：启动线程*/
public class TicketDemo {public static void main(String[] args) {// 创建任务类对象Ticket ticket = new Ticket();// 创建三个线程类对象Thread t1 = new Thread(ticket);Thread t2 = new Thread(ticket);Thread t3 = new Thread(ticket);// 给三个线程命名t1.setName("窗口1");t2.setName("窗口2");t3.setName("窗口3");// 开启三个线程t1.start();t2.start();t3.start();}
}

注意 : 以上代码是有问题 , 接下来继续改进

  • 因为出票是有时间的 , 所有现在在每次买票之前, 休眠100毫秒 , 尝试执行代码

package com.itheima.ticket_demo;/*电影院*/
public class Ticket implements Runnable {private int ticketCount = 100; // 一共有一百张票@Overridepublic void run() {while (true) {// 如果票的数量为0 , 那么停止买票if (ticketCount <= 0) {break;} else {// 模拟出票的时间try {Thread.sleep(100);} catch (InterruptedException e) {e.printStackTrace();}// 有剩余的票 , 开始卖票ticketCount--;System.out.println(Thread.currentThread().getName() + "卖出一张票,剩下" + ticketCount + "张");}}}
}

package com.itheima.ticket_demo;/*1 定义一个类Ticket实现Runnable接口，里面定义一个成员变量：private int ticketCount = 100;2 在Ticket类中重写run()方法实现卖票，代码步骤如下A：判断票数大于0，就卖票，并告知是哪个窗口卖的B：票数要减1C：卖光之后，线程停止3 定义一个测试类TicketDemo，里面有main方法，代码步骤如下A：创建Ticket类的对象B：创建三个Thread类的对象，把Ticket对象作为构造方法的参数，并给出对应的窗口名称C：启动线程*/
public class TicketDemo {public static void main(String[] args) {// 创建任务类对象Ticket ticket = new Ticket();// 创建三个线程类对象Thread t1 = new Thread(ticket);Thread t2 = new Thread(ticket);Thread t3 = new Thread(ticket);// 给三个线程命名t1.setName("窗口1");t2.setName("窗口2");t3.setName("窗口3");// 开启三个线程t1.start();t2.start();t3.start();}
}

  • 通过上述代码的执行结果 , 发现了出现了负号票 , 和相同的票 , 数据有问题

    • 问题出现的原因 : 多个线程在对共享数据进行读改写的时候，可能导致的数据错乱就是线程的安全问题了

线程的同步

概述 : java允许多线程并发执行，当多个线程同时操作一个可共享的资源变量时（如数据的增删改查），将会导致数据不准确，相互之间产生冲突，因此加入同步锁以避免在该线程没有完成操作之前，被其他线程的调用，从而保证该变量的唯一性和准确性

分类

  • 同步代码块
  • 同步方法
  • 锁机制。Lock
同步代码块
同步代码块 : 锁住多条语句操作共享数据，可以使用同步代码块实现第一部分 : 格式synchronized(任意对象) {多条语句操作共享数据的代码}第二部分 : 注意1 默认情况锁是打开的，只要有一个线程进去执行代码了，锁就会关闭2 当线程执行完出来了，锁才会自动打开第三部分 : 同步的好处和弊端好处 : 解决了多线程的数据安全问题弊端 : 当线程很多时，因为每个线程都会去判断同步上的锁，这是很耗费资源的，无形中会降低程序的运行效率
public class Ticket implements Runnable {private int ticketCount = 100; // 一共有一百张票@Overridepublic void run() {while (true) {synchronized (Ticket.class) {// 如果票的数量为0 , 那么停止买票if (ticketCount <= 0) {break;} else {// 模拟出票的时间try {Thread.sleep(100);} catch (InterruptedException e) {e.printStackTrace();}// 有剩余的票 , 开始卖票ticketCount--;System.out.println(Thread.currentThread().getName() + "卖出一张票,剩下" + ticketCount + "张");}}}}
}

 

package com.itheima.synchronized_demo1;/*1 定义一个类Ticket实现Runnable接口，里面定义一个成员变量：private int ticketCount = 100;2 在Ticket类中重写run()方法实现卖票，代码步骤如下A：判断票数大于0，就卖票，并告知是哪个窗口卖的B：票数要减1C：卖光之后，线程停止3 定义一个测试类TicketDemo，里面有main方法，代码步骤如下A：创建Ticket类的对象B：创建三个Thread类的对象，把Ticket对象作为构造方法的参数，并给出对应的窗口名称C：启动线程*/
public class TicketDemo {public static void main(String[] args) {// 创建任务类对象Ticket ticket = new Ticket();// 创建三个线程类对象Thread t1 = new Thread(ticket);Thread t2 = new Thread(ticket);Thread t3 = new Thread(ticket);// 给三个线程命名t1.setName("窗口1");t2.setName("窗口2");t3.setName("窗口3");// 开启三个线程t1.start();t2.start();t3.start();}
}
同步方法
同步方法：就是把synchronized关键字加到方法上格式：修饰符 synchronized 返回值类型 方法名(方法参数) {    }同步代码块和同步方法的区别:1 同步代码块可以锁住指定代码,同步方法是锁住方法中所有代码2 同步代码块可以指定锁对象,同步方法不能指定锁对象注意 : 同步方法时不能指定锁对象的 , 但是有默认存在的锁对象的。1 对于非static方法,同步锁就是this。2 对于static方法,我们使用当前方法所在类的字节码对象(类名.class)。   Class类型的对象
package com.itheima.synchronized_demo2;/*同步方法：就是把synchronized关键字加到方法上格式：修饰符 synchronized 返回值类型 方法名(方法参数) {    }同步代码块和同步方法的区别:1 同步代码块可以锁住指定代码,同步方法是锁住方法中所有代码2 同步代码块可以指定锁对象,同步方法不能指定锁对象注意 : 同步方法时不能指定锁对象的 , 但是有默认存在的锁对象的。1 对于非static方法,同步锁就是this。2 对于static方法,我们使用当前方法所在类的字节码对象(类名.class)。   Class类型的对象*/
public class Ticket implements Runnable {private int ticketCount = 100; // 一共有一百张票@Overridepublic void run() {while (true) {if (method()) {break;}}}private synchronized boolean method() {// 如果票的数量为0 , 那么停止买票if (ticketCount <= 0) {return true;} else {// 模拟出票的时间try {Thread.sleep(100);} catch (InterruptedException e) {e.printStackTrace();}// 有剩余的票 , 开始卖票ticketCount--;System.out.println(Thread.currentThread().getName() + "卖出一张票,剩下" + ticketCount + "张");return false;}}
}

 

package com.itheima.synchronized_demo2;/*1 定义一个类Ticket实现Runnable接口，里面定义一个成员变量：private int ticketCount = 100;2 在Ticket类中重写run()方法实现卖票，代码步骤如下A：判断票数大于0，就卖票，并告知是哪个窗口卖的B：票数要减1C：卖光之后，线程停止3 定义一个测试类TicketDemo，里面有main方法，代码步骤如下A：创建Ticket类的对象B：创建三个Thread类的对象，把Ticket对象作为构造方法的参数，并给出对应的窗口名称C：启动线程*/
public class TicketDemo {public static void main(String[] args) {// 创建任务类对象Ticket ticket = new Ticket();// 创建三个线程类对象Thread t1 = new Thread(ticket);Thread t2 = new Thread(ticket);Thread t3 = new Thread(ticket);// 给三个线程命名t1.setName("窗口1");t2.setName("窗口2");t3.setName("窗口3");// 开启三个线程t1.start();t2.start();t3.start();}
}
Lock锁
虽然我们可以理解同步代码块和同步方法的锁对象问题，但是我们并没有直接看到在哪里加上了锁，在哪里释放了锁，
为了更清晰的表达如何加锁和释放锁，JDK5以后提供了一个新的锁对象LockLock中提供了获得锁和释放锁的方法void lock()：获得锁void unlock()：释放锁Lock是接口不能直接实例化，这里采用它的实现类ReentrantLock来实例化ReentrantLock的构造方法ReentrantLock()：创建一个ReentrantLock的实例注意：多个线程使用相同的Lock锁对象，需要多线程操作数据的代码放在lock()和unLock()方法之间。一定要确保unlock最后能够调用
package com.itheima.synchronized_demo3;import java.util.concurrent.locks.ReentrantLock;/*虽然我们可以理解同步代码块和同步方法的锁对象问题，但是我们并没有直接看到在哪里加上了锁，在哪里释放了锁，为了更清晰的表达如何加锁和释放锁，JDK5以后提供了一个新的锁对象LockLock中提供了获得锁和释放锁的方法void lock()：获得锁void unlock()：释放锁Lock是接口不能直接实例化，这里采用它的实现类ReentrantLock来实例化ReentrantLock的构造方法ReentrantLock​()：创建一个ReentrantLock的实例注意：多个线程使用相同的Lock锁对象，需要多线程操作数据的代码放在lock()和unLock()方法之间。一定要确保unlock最后能够调用*/
public class Ticket implements Runnable {private int ticketCount = 100; // 一共有一百张票ReentrantLock lock = new ReentrantLock();@Overridepublic void run() {while (true) {try {lock.lock();// 加锁// 如果票的数量为0 , 那么停止买票if (ticketCount <= 0) {break;} else {// 模拟出票的时间Thread.sleep(100);// 有剩余的票 , 开始卖票ticketCount--;System.out.println(Thread.currentThread().getName() + "卖出一张票,剩下" + ticketCount + "张");}} catch (InterruptedException e) {e.printStackTrace();} finally {lock.unlock();// 释放锁}}}
}

 

package com.itheima.synchronized_demo3;/*1 定义一个类Ticket实现Runnable接口，里面定义一个成员变量：private int ticketCount = 100;2 在Ticket类中重写run()方法实现卖票，代码步骤如下A：判断票数大于0，就卖票，并告知是哪个窗口卖的B：票数要减1C：卖光之后，线程停止3 定义一个测试类TicketDemo，里面有main方法，代码步骤如下A：创建Ticket类的对象B：创建三个Thread类的对象，把Ticket对象作为构造方法的参数，并给出对应的窗口名称C：启动线程*/
public class TicketDemo {public static void main(String[] args) {// 创建任务类对象Ticket ticket = new Ticket();// 创建三个线程类对象Thread t1 = new Thread(ticket);Thread t2 = new Thread(ticket);Thread t3 = new Thread(ticket);// 给三个线程命名t1.setName("窗口1");t2.setName("窗口2");t3.setName("窗口3");// 开启三个线程t1.start();t2.start();t3.start();}
}

2.线程死锁

概述:

  • 死锁是一种少见的，而且难于调试的错误，在两个线程对两个同步锁对象具有循环依赖时，就会大概率的出现死锁。我们要避免死锁的产生。否则一旦死锁，除了重启没有其他办法的

产生条件:

  • 多个线程

  • 存在锁对象的循环依赖

代码实践
package com.itheima.deadlock_demo;/*死锁 :死锁是一种少见的，而且难于调试的错误，在两个线程对两个同步锁对象具有循环依赖时，就会大概率的出现死锁。我们要避免死锁的产生。否则一旦死锁，除了重启没有其他办法的*/
public class DeadLockDemo {public static void main(String[] args) {String 筷子A = "筷子A";String 筷子B = "筷子B";new Thread(new Runnable() {@Overridepublic void run() {while (true) {synchronized (筷子A) {System.out.println("小白拿到了筷子A ,等待筷子B....");synchronized (筷子B) {System.out.println("小白拿到了筷子A和筷子B , 开吃!!!!!");}}try {Thread.sleep(100);} catch (InterruptedException e) {e.printStackTrace();}}}}, "小白").start();new Thread(new Runnable() {@Overridepublic void run() {while (true) {synchronized (筷子B) {System.out.println("小黑拿到了筷子B ,等待筷子A....");synchronized (筷子A) {System.out.println("小黑拿到了筷子B和筷子A , 开吃!!!!!");}}try {Thread.sleep(100);} catch (InterruptedException e) {e.printStackTrace();}}}}, "小黑").start();}
}

3.线程的状态

 

4.线程通信

  • 线程间的通讯技术就是通过等待和唤醒机制，来实现多个线程协同操作完成某一项任务，例如经典的生产者和消费者案例。等待唤醒机制其实就是让线程进入等待状态或者让线程从等待状态中唤醒，需要用到两种方法，如下：
  • 等待方法 :
    • void wait() 让线程进入无限等待。
    • void wait(long timeout) 让线程进入计时等待
    • 以上两个方法调用会导致当前线程释放掉锁资源。
  • 唤醒方法 :
    • void notify() 唤醒在此对象监视器（锁对象）上等待的单个线程。
    • void notifyAll() 唤醒在此对象监视器上等待的所有线程。
    • 以上两个方法调用不会导致当前线程释放掉锁资源
  • 注意
    • 等待和唤醒的方法，都要使用锁对象调用（需要在同步代码块中调用)
    • 等待和唤醒方法应该使用相同的锁对象调用
package com.itheima.waitnotify_demo;/*1 线程进入无限等待注意：进入无限等待需要使用锁在同步代码中调用wait方法*/
public class Test1 {public static void main(String[] args) {Object obj = new Object(); // 作为锁对象new Thread(new Runnable() {@Overridepublic void run() {synchronized (obj) {System.out.println("线程开始执行");System.out.println("线程进入无线等待....");try {obj.wait(); // 进入无线等待状态 , 并释放锁} catch (InterruptedException e) {e.printStackTrace();}System.out.println("无线等待被唤醒....");}}}).start();}
}
package com.itheima.waitnotify_demo;/*线程进入无限等待后被唤醒注意：等待和唤醒是两个或多个线程之间实现的。进入无限等待的线程是不会自动唤醒，只能通过其他线程来唤醒。*/
public class Test2 {public static void main(String[] args) {Object obj = new Object(); // 作为锁对象new Thread(new Runnable() {@Overridepublic void run() {synchronized (obj) {System.out.println("线程开始执行");System.out.println("线程进入无线等待....");try {obj.wait(); // 进入无线等待状态 , 并释放锁} catch (InterruptedException e) {e.printStackTrace();}System.out.println("无线等待被唤醒....");}}}).start();new Thread(new Runnable() {@Overridepublic void run() {try {Thread.sleep(3000);} catch (InterruptedException e) {e.printStackTrace();}synchronized (obj) {obj.notify();// 随机唤醒此监视器中等待的线程 , 不会释放锁System.out.println("唤醒后 , 5秒钟后释放锁");try {Thread.sleep(5000);} catch (InterruptedException e) {e.printStackTrace();}}// 释放锁}}).start();}
}
package com.itheima.waitnotify_demo;/*3 线程进入计时等待并唤醒注意：进入计时等待的线程，时间结束前可以被其他线程唤醒。时间结束后会自动唤醒*/
public class Test3 {public static void main(String[] args) {new Thread(new Runnable() {@Overridepublic void run() {synchronized (Test3.class) {System.out.println("获取到锁 , 开始执行");try {System.out.println("进入计时等待...3秒");Test3.class.wait(3000);} catch (InterruptedException e) {e.printStackTrace();}System.out.println("自动唤醒.");}}}).start();}
}
  • 生产者和消费者案例
package com.itheima.waitnotify_demo2;import sun.security.krb5.internal.crypto.Des;/*生产者步骤：1，判断桌子上是否有汉堡包如果有就等待，如果没有才生产。2，把汉堡包放在桌子上。3，叫醒等待的消费者开吃*/
public class Cooker implements Runnable {@Overridepublic void run() {while (true) {synchronized (Desk.lock) {if (Desk.count == 0) {break;} else {if (Desk.flag) {// 桌子上有食物try {Desk.lock.wait();} catch (InterruptedException e) {e.printStackTrace();}} else {// 桌子上没有食物System.out.println("厨师生产了一个汉堡包...");Desk.flag = true;Desk.lock.notify();}}}}}
}

 

package com.itheima.waitnotify_demo2;import sun.security.krb5.internal.crypto.Des;/*消费者步骤：1，判断桌子上是否有汉堡包。2，如果没有就等待。3，如果有就开吃4，吃完之后，桌子上的汉堡包就没有了叫醒等待的生产者继续生产汉堡包的总数量减一*/
public class Foodie implements Runnable {@Overridepublic void run() {while (true) {synchronized (Desk.lock) {if (Desk.count == 0) {break;} else {if (Desk.flag) {// 桌子上有食物System.out.println("吃货吃了一个汉堡包...");Desk.count--; // 汉堡包的数量减少一个Desk.flag = false;// 桌子上的食物被吃掉 , 值为falseDesk.lock.notify();} else {// 桌子上没有食物try {Desk.lock.wait();} catch (InterruptedException e) {e.printStackTrace();}}}}}}
}

package com.itheima.waitnotify_demo2;public class Test {public static void main(String[] args) {new Thread(new Foodie()).start();new Thread(new Cooker()).start();}
}

 

5.线程池

线程使用存在的问题

  • 如果并发的线程数量很多，并且每个线程都是执行一个时间很短的任务就结束了，这样频繁创建线程就会大大降低系统的效率，因为频繁创建线程和销毁线程需要时间。 如果大量线程在执行，会涉及到线程间上下文的切换，会极大的消耗CPU运算资源

线程池的介绍

  • 其实就是一个容纳多个线程的容器，其中的线程可以反复使用，省去了频繁创建线程对象的操作，无需反复创建线程而消耗过多资源。

线程池使用的大致流程

  • 创建线程池指定线程开启的数量

  • 提交任务给线程池，线程池中的线程就会获取任务，进行处理任务。

  • 线程处理完任务，不会销毁，而是返回到线程池中，等待下一个任务执行。

  • 如果线程池中的所有线程都被占用，提交的任务，只能等待线程池中的线程处理完当前任

线程池的好处

  • 降低资源消耗。减少了创建和销毁线程的次数，每个工作线程都可以被重复利用，可执行多个任务。

  • 提高响应速度。当任务到达时，任务可以不需要等待线程创建 , 就能立即执行。

  • 提高线程的可管理性。可以根据系统的承受能力，调整线程池中工作线线程的数目，防止因为消耗过多的内存 (每个线程需要大约1MB内存，线程开的越多，消耗的内存也就越大，最后死机)。

Java提供好的线程池

  • java.util.concurrent.ExecutorService 是线程池接口类型。使用时我们不需自己实现，JDK已经帮我们实现好了

  • 获取线程池我们使用工具类java.util.concurrent.Executors的静态方

    • public static ExecutorService newFixedThreadPool (int num) : 指定线程池最大线程池数量获取线程池

  • 线程池ExecutorService的相关方法

    • <T> Future<T> submit(Callable<T> task)

    • Future<?> submit(Runnable task)

  • 关闭线程池方法（一般不使用关闭方法，除非后期不用或者很长时间都不用，就可以关闭）

    • void shutdown() 启动一次顺序关闭，执行以前提交的任务，但不接受新任务

线程池处理Runnable任务
package com.itheima.threadpool_demo;import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;/*1 需求 :使用线程池模拟游泳教练教学生游泳。游泳馆（线程池）内有3名教练（线程）游泳馆招收了5名学员学习游泳（任务）。2 实现步骤：创建线程池指定3个线程定义学员类实现Runnable，创建学员对象给线程池*/
public class Test1 {public static void main(String[] args) {// 创建指定线程的线程池ExecutorService threadPool = Executors.newFixedThreadPool(3);// 提交任务threadPool.submit(new Student("小花"));threadPool.submit(new Student("小红"));threadPool.submit(new Student("小明"));threadPool.submit(new Student("小亮"));threadPool.submit(new Student("小白"));threadPool.shutdown();// 关闭线程池}
}class Student implements Runnable {private String name;public Student(String name) {this.name = name;}@Overridepublic void run() {String coach = Thread.currentThread().getName();System.out.println(coach + "正在教" + name + "游泳...");try {Thread.sleep(3000);} catch (InterruptedException e) {e.printStackTrace();}System.out.println(coach + "教" + name + "游泳完毕.");}
}
线程池处理Callable任务
package com.itheima.threadpool_demo;import java.util.concurrent.*;/*需求: Callable任务处理使用步骤1 创建线程池2 定义Callable任务3 创建Callable任务，提交任务给线程池4 获取执行结果<T> Future<T> submit(Callable<T> task) : 提交Callable任务方法    返回值类型Future的作用就是为了获取任务执行的结果。Future是一个接口，里面存在一个get方法用来获取值练一练：使用线程池计算 从0~n的和，并将结果返回*/
public class Test2 {public static void main(String[] args) throws ExecutionException, InterruptedException {// 创建指定线程数量的线程池ExecutorService threadPool = Executors.newFixedThreadPool(10);Future<Integer> future = threadPool.submit(new CalculateTask(100));Integer sum = future.get();System.out.println(sum);}
}// 使用线程池计算 从0~n的和，并将结果返回
class CalculateTask implements Callable<Integer> {private int num;public CalculateTask(int num) {this.num = num;}@Overridepublic Integer call() throws Exception {int sum = 0;// 求和变量for (int i = 0; i <= num; i++) {sum += i;}return sum;}
}

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.mzph.cn/news/753869.shtml

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

LeetCode刷题记录：（11）组合（初识回溯算法）

LeetCode刷题记录：（11）组合（初识回溯算法）

leetcode传送通道 暂时记录&#xff0c;这篇没啥营养&#xff0c;不用看了 class Solution {List<List<Integer>> result new ArrayList<>(); // 存所有组合List<Integer> path new LinkedList<>(); //存每一个组合public List<List<Int…
阅读更多...
世界第一个AI软件工程师问世！

世界第一个AI软件工程师问世！

2024年3月13日&#xff0c;科技公司Cognition推出了世界上第一位人工智能软件工程师Devin AI。这项创新有望利用人工智能编码和机器学习的力量加快发展。Devin AI不仅仅是帮助&#xff1b;它是一个成熟的队友&#xff0c;发挥智能编码自动化和自主人工智能编码的魔力&#xff0…
阅读更多...
SQL注入无回显，利用DNSlog构造方式

SQL注入无回显，利用DNSlog构造方式

没有回显的情况下&#xff0c;一般编写脚本&#xff0c;进行自动化注入。但与此同时&#xff0c;由于 防火墙的存在&#xff0c;容易被封禁 IP&#xff0c;可以尝试调整请求频率&#xff0c;有条件的使用代理池进行请求。 此时也可以使用 DNSlog 注入&#xff0c;原理就是把服…
阅读更多...
salesforce生产环境如何删除触发器

salesforce生产环境如何删除触发器

由于生产环境不能直接删除触发器&#xff0c;所以需要在sandbox中先让触发器inactive再部署到生产环境&#xff0c;就可以让触发器失效了。
阅读更多...
C++基础6：面向对象程序设计思想和类(上)

C++基础6：面向对象程序设计思想和类(上)

此专栏为移动机器人知识体系下的编程语言中的 C {\rm C} C从入门到深入的专栏&#xff0c;参考书籍&#xff1a;《深入浅出 C {\rm C} C》(马晓锐)和《从 C {\rm C} C到 C {\rm C} C精通面向对象编程》(曾凡锋等)。 6.面向对象程序设计思想和类 6.1 程序设计思想 6.1.1 结构化…
阅读更多...
春招第一面-京东

春招第一面-京东

宝子们&#xff0c;卷起来吧&#xff01; 1、自我介绍 2、实习项目 3、实习项目分库分表怎么做的&#xff1f; 4、分布式主键用的是什么&#xff1f;雪花ID是怎么样的&#xff0c;有什么问题&#xff1f; 5、实习业务具体是干嘛 6、你们这个业务为啥不用es&#xff0c;如…
阅读更多...
vscode中自动生成python的UML类图的插件

vscode中自动生成python的UML类图的插件

需求&#xff1a; 阅读一些源码时&#xff0c;想直观的看一下它的UML类关系图。 搜索发现已有相关的软件可以实现这个功能。 Linux系统&#xff1a; 安装pylint pip3 install pylint 使用pyreverse命令 pyreverse -ASmy -o png test.py 生成名为classes.png的UML类图 参考…
阅读更多...
苍穹外卖-day08：导入地址簿功能代码（单表crud）、用户下单（业务逻辑）、订单支付（业务逻辑，cpolar软件）

苍穹外卖-day08：导入地址簿功能代码（单表crud）、用户下单（业务逻辑）、订单支付（业务逻辑，cpolar软件）

苍穹外卖-day08 课程内容 导入地址簿功能代码用户下单订单支付 功能实现&#xff1a;用户下单、订单支付 用户下单效果图&#xff1a; 订单支付效果图&#xff1a; 1. 导入地址簿功能代码&#xff08;单表crud&#xff09; 1.1 需求分析和设计 1.1.1 产品原型&#xff08…
阅读更多...
苍穹外卖-day04：项目实战-套餐管理（新增套餐，分页查询套餐，删除套餐，修改套餐，起售停售套餐）业务类似于菜品模块

苍穹外卖-day04：项目实战-套餐管理（新增套餐，分页查询套餐，删除套餐，修改套餐，起售停售套餐）业务类似于菜品模块

苍穹外卖-day04 课程内容 新增套餐套餐分页查询删除套餐修改套餐起售停售套餐 要求&#xff1a; 根据产品原型进行需求分析&#xff0c;分析出业务规则设计接口梳理表之间的关系&#xff08;分类表、菜品表、套餐表、口味表、套餐菜品关系表&#xff09;根据接口设计进行代…
阅读更多...
rocky9 编写一键安装mysql 的sh脚本

rocky9 编写一键安装mysql 的sh脚本

基本操作步骤 1、虚拟机最小化安装rocky9系统&#xff0c;安装后克隆一个系统&#xff1b;1个用来获取下载的rpm包&#xff0c;一个用来编写sh 测试脚本&#xff1b; 2、修改虚拟机的 yum配置文件&#xff0c;获取获取rpm程序 &#xff1a;启用缓存&#xff0c;并修改yum下载…
阅读更多...
比特币,区块链及相关概念简介(二）

比特币,区块链及相关概念简介(二）

目录 什么是挖矿挖矿是否代表资源浪费为什么挖矿能维持比特币网络安全性&#xff1f;是怎么做到的呢&#xff1f;该系列文章链接 以下内容结合了chatgpt 3.5以及网络文章。 用于学习记录。 简介&#xff1a; 介绍了什么是挖矿&#xff0c;挖矿是否代表资源浪费&#xff0c;挖矿…
阅读更多...
四个按键控制数码管分别显示6，8 ，A，F

四个按键控制数码管分别显示6，8 ，A，F

#include<reg52.h> typedef unsigned int u16; //重新定义系统默认数据类型 typedef unsigned char u8; #define SMG_A_DP_PORT P0 //使用宏定义定义P0端口&#xff0c;数码管段码口 …
阅读更多...
【数据结构与算法】：非递归实现快速排序、归并排序

【数据结构与算法】：非递归实现快速排序、归并排序

&#x1f525;个人主页&#xff1a; Quitecoder &#x1f525;专栏&#xff1a;数据结构与算法 上篇文章我们详细讲解了递归版本的快速排序&#xff0c;本篇我们来探究非递归实现快速排序和归并排序 目录 1.非递归实现快速排序1.1 提取单趟排序1.2 用栈实现的具体思路1.3 代码…
阅读更多...
Linux：git的基础操作

Linux：git的基础操作

git的下载 版本控制系统一般分为两种&#xff0c;集中式版本控制系统&#xff0c;分布式版本控制系统 什么是集中式版本控制系统&#xff1a;版本库集中存放在中央服务器&#xff0c;工作时候使用自己的电脑&#xff0c;当工作时候在中央服务器上拉取最新版本的代码&#xff0c…
阅读更多...
U盘变身“本地磁盘”？数据恢复与防范策略大揭秘

U盘变身“本地磁盘”？数据恢复与防范策略大揭秘

一、突发状况&#xff1a;U盘秒变“本地磁盘” 在日常工作生活中&#xff0c;U盘凭借其便携性和大容量&#xff0c;成为我们存储和传输数据的重要工具。然而&#xff0c;有时我们会遇到这样一个棘手的问题&#xff1a;原本应显示为可移动磁盘的U盘&#xff0c;在插入电脑后却突…
阅读更多...
ModuleNotFoundError: No module named，（python跨文件导包）

ModuleNotFoundError: No module named，（python跨文件导包）

方法一&#xff1a;在文件中开头加入&#xff1a; import os import sys REPO os.path.dirname(os.path.dirname(os.path.realpath(__file__))) sys.path.append(REPO) 方法二&#xff1a;直接添加环境变量&#xff08;比较好用&#xff09; # 添加环境变量export PYTHONPAT…
阅读更多...
Nginx 的安装、启动和关闭

Nginx 的安装、启动和关闭

文章目录 一、背景说明二、Nginx 的安装2.1、依赖的安装2.2、Nginx 安装2.3、验证安装 三、启动 Nginx3.1、普通启动3.2、如何判断nginx已启动3.3、通过配置启动3.4、设置开机启动 四、关闭 Nginx4.1、优雅地关闭4.2、快速关闭4.3、只关闭主进程4.4、使用nginx关闭服务 五、重启…
阅读更多...
R语言：microeco:一个用于微生物群落生态学数据挖掘的R包：第七：trans_network class

R语言：microeco:一个用于微生物群落生态学数据挖掘的R包：第七：trans_network class

# 网络是研究微生物生态共现模式的常用方法。在这一部分中&#xff0c;我们描述了trans_network类的所有核心内容。 # 网络构建方法可分为基于关联的和非基于关联的两种。有几种方法可以用来计算相关性和显著性。 #我们首先介绍了基于关联的网络。trans_network中的cal_cor参数…
阅读更多...
编曲学习：如何编写钢琴织体 Cubase12逻辑预置 需要弄明白的问题

编曲学习：如何编写钢琴织体 Cubase12逻辑预置 需要弄明白的问题

钢琴织体是指演奏形式、方式，同一个和弦进行可以用很多种不同的演奏方法。常用织体有分解和弦，柱式和弦，琶音织体，混合织体。 在编写钢琴织体前，先定好歌曲的调。 Cubase小技巧：把钢琴轨道向上拖动打和弦轨道，就可以显示和弦！如果你有一些参考工程，不知道用了哪些和…
阅读更多...
yum安装mysql及数据库补全功能

yum安装mysql及数据库补全功能

centos7上面没有mysql&#xff0c;它的数据库名字叫做mariadb [rootlocalhost ~]#yum install mariadb-server -y [rootlocalhost ~]#systemctl start mariadb.service [rootlocalhost ~]#systemctl stop firewalld [rootlocalhost ~]#setenforce 0 [rootlocalhost ~]#ss -na…
阅读更多...
最新文章

Copyright @ 2022~2023