多线程-线程池原子性并发工具类

1.线程池

1.线程状态

虚拟机中线程的六种状态

新建状态（NEW）    --创建线程

就绪状态（RUNNABLE）    --start方法

阻塞状态（BLOCKED）    --无法获得锁对象

等待状态（WAITING）    --with方法

计时等待（TIME_WAITING）    --sleep方法

结束状态（TERMINATED）    --全部代码运行完毕

2.线程池基本原理

以前写多线程的弊端

1.用到线程的时候就创建

2.用完之后线程消失

解决方案

1.创建一个池子，池子中是空的

2.有任务需要执行时，才会创建线程对象。当任务执行完毕，线程对象归还给池子

多线程运行时，系统不断创建和销毁新的线程，成本非常高，会过度的消耗系统资源，从而可能导致系统资源崩溃，使用线程池就是最好的选择

工作机制：

在线程池的编程模式下，任务是分配给整个线程池的，而不是直接提交给某个线程，线程池拿到任务后，就会在内部寻找是否有空闲的线程，如果有，则将任务交个某个空闲线程

3.Executors默认线程池

1.创建一个池子，池子中是空的-->创建Executors中的静态方法

2.有任务需要执行时，才会创建线程对象。当任务执行完毕，线程对象归还给池子-->submit方法

注：池子会自动的帮我们创建对象，任务执行完毕，也会自动把线程对象归还池子

3.所有任务全部执行完毕，关闭连接池-->shutdown方法

package com.mythreadpool;import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;public class MyThreadPoolDemo {public static void main(String[] args) throws InterruptedException {//1.创建一个默认的线程池对象，池子中默认是空的，默认最多可以容纳int类型的最大值ExecutorService executorService = Executors.newCachedThreadPool();//Executors --- 可以帮助我们创建线程池对象//ExecutorService --- 可以帮助我们控制线程池executorService.submit(()->{System.out.println(Thread.currentThread().getName()+"在执行了");});//Thread.sleep(2000);executorService.submit(()->{System.out.println(Thread.currentThread().getName()+"在执行了");});executorService.shutdown();}
}

4.Executors创建指定上线的线程池

package com.mythreadpool;import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;public class MyThreadPoolDemo2 {public static void main(String[] args) {//参数不是初始值而是最大值ExecutorService executorService = Executors.newFixedThreadPool(10);executorService.submit(()->{System.out.println(Thread.currentThread().getName()+"在执行了");});executorService.submit(()->{System.out.println(Thread.currentThread().getName()+"在执行了");});executorService.shutdown();}
}

5.ThreadPoolExecutor

ThreadPoolExecutor pool = new ThreadPoolExecutor（核心线程数量，最大线程数量，空闲线程最大存活时间，任务队列，创建线程工厂，任务的拒绝策略）;

参数一：核心线程数量---不能小于0

参数二：最大线程数量---不能小于0，最大数量>=核心线程数量

参数三：空闲线程最大存活时间---不能小于0

参数四：时间单位---时间单位

参数五：任务队列---不能为null

参数六：创建线程工厂---不能为null

参数七：任务的拒绝策略---不能为null

package com.mythreadpool;public class MyRunnable implements Runnable{@Overridepublic void run() {System.out.println(Thread.currentThread().getName()+"在执行了");}
}

package com.mythreadpool;import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;public class MyThreadPoolDemo3 {//参数一：核心线程数量//参数二：最大线程数量//参数三：空闲线程最大存活时间//参数四：时间单位//参数五：任务队列//参数六：创建线程工厂//参数七：任务的拒绝策略public static void main(String[] args) {ThreadPoolExecutor pool = new ThreadPoolExecutor(2,5,2, TimeUnit.SECONDS,new ArrayBlockingQueue<>(10), Executors.defaultThreadFactory(),new ThreadPoolExecutor.AbortPolicy());pool.submit(new MyRunnable());pool.submit(new MyRunnable());pool.shutdown();}
}

6.参数详解

任务拒绝策略

ThreadPoolExecutor.AbortPolicy        丢弃任务并抛出RejectedExecutionException异常。是默认的策略

ThreadPoolExecutor.DiscardPolicy        丢弃任务，但是不抛出异常 这是不推荐的做法

ThreadPoolExecutor.DiscardOldertPolicy        抛弃队列中等待最久的任务 然后把当前任务加入队列中

ThreadPoolExecutor.CallerRunsPolicy        调用任务的run()方法绕过线程池直接执行

package com.mythreadpool;import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;public class MyThreadPoolDemo4 {//参数一：核心线程数量//参数二：最大线程数量//参数三：空闲线程最大存活时间//参数四：时间单位  ---TimeUnit//参数五：任务队列  ---让任务在队列中等着，等有线程空闲了，再从这个队列中获取任务并执行//参数六：创建线程工厂    ---按照默认的方式创建线程对象//参数七：任务的拒绝策略   ---1.什么时候拒绝任务//2.如何拒绝public static void main(String[] args) {ThreadPoolExecutor pool = new ThreadPoolExecutor(2,5,2,TimeUnit.SECONDS,new ArrayBlockingQueue<>(10),Executors.defaultThreadFactory(),new ThreadPoolExecutor.AbortPolicy());for (int i=0; i<16; i++) {pool.submit(new MyRunnable());}pool.shutdown();}
}

触发了任务拒绝策略 

7.volatile

Volatile关键字

强制线程每次在使用的时候，都会看一下共享区域最新的值

package com.myvolatile;public class Money {public volatile static int money = 100000;
}

package com.myvolatile;public class MyThread1 extends Thread{@Overridepublic void run(){while (Money.money == 100000){}System.out.println("结婚积极已经不是十万了");}
}

package com.myvolatile;public class MyThread2 extends Thread{@Overridepublic void run(){try {Thread.sleep(10);} catch (InterruptedException e) {throw new RuntimeException(e);}Money.money = 90000;}
}

package com.myvolatile;public class Demo {public static void main(String[] args) {MyThread1 t1 = new MyThread1();t1.setName("小路同学");t1.start();MyThread2 t2 = new MyThread2();t2.setName("小花同学");t2.start();}
}

若不加volatile关键字，则会出现不输出且运行不停止

8.用synchronize解决

Synchronize同步代码块

1.线程获得锁

2.清空变量副本

3.拷贝共享变量最新的值到变量副本中

4.执行代码

5.将修改后变量副本中的值赋值给共享数据

6.释放锁

package com.myvolatile2;public class Money {public static Object Lock = new Object();public volatile static int money = 100000;
}

package com.myvolatile2;public class MyThread1 extends Thread{@Overridepublic void run(){while (true){synchronized (Money.Lock){if(Money.money != 100000){System.out.println("结婚积极已经不是十万了");break;}}}}
}

package com.myvolatile2;public class MyThread2 extends Thread{@Overridepublic void run(){synchronized (Money.Lock) {try {Thread.sleep(10);} catch (InterruptedException e) {throw new RuntimeException(e);}Money.money = 90000;}}
}

package com.myvolatile2;import com.myvolatile.MyThread1;
import com.myvolatile.MyThread2;public class Demo {public static void main(String[] args) {MyThread1 t1 = new MyThread1();t1.setName("小路同学");t1.start();MyThread2 t2 = new MyThread2();t2.setName("小花同学");t2.start();}
}

2.原子性

1.原子性

所谓的原子性是指在一次操作或者多次操作中，要么所有的操作全部都得到了执行并且不会收到任何因素的干扰二中断，要么所有的操作都不执行，多个操作是一个不可分割的整体

package com.threadatom;public class MyAtomThread implements Runnable{private int count = 0; //送冰激凌的数量@Overridepublic void run() {for (int i = 0; i < 100; i++) {//1.从共享数据中读取数据到本线程栈中//2.修改本线程栈中变量副本的值//3.会把本线程栈中变量副本的值赋值给共享数据count++;System.out.println("已经送了"+count+"个冰激凌");}}
}

package com.threadatom;public class AtomDemo {public static void main(String[] args) {MyAtomThread atom = new MyAtomThread();for (int i = 0; i < 100; i++) {new Thread(atom).start();}}
}

可以得出

count++不是一个原子性操作，也就是说他在执行的过程中，有可能被其他线程打断操作 

2.volatile关键字不能保证原子性

volatile关键字：

只能保证线程每次在使用共享数据的时候是最新值

但是不能保证原子性

有两种解决方案

加锁可以解决问题

package com.threadatom;public class MyAtomThread implements Runnable{private int count = 0; //送冰激凌的数量private Object lock = new Object();@Overridepublic void run() {for (int i = 0; i < 100; i++) {//1.从共享数据中读取数据到本线程栈中//2.修改本线程栈中变量副本的值//3.会把本线程栈中变量副本的值赋值给共享数据synchronized (lock) {count++;System.out.println("已经送了"+count+"个冰激凌");}}}
}

但加锁的方式需要判断锁，获取锁，释放锁等，比较慢，且性能较低

3.AtomicInteger

另一种方法就是用AtomicInteger

构造方法

方法名说明
public AtomicInteger()初始化一个默认值为0的原子型Integer
public AtomicInteger(int initialValue)初始化一个指定值的原子型Integer
package com.threadatom2;import java.util.concurrent.atomic.AtomicInteger;public class MyAtomIntegerDemo1 {//public AtomicInteger()	初始化一个默认值为0的原子型Integer//public AtomicInteger(int initialValue)	初始化一个指定值的原子型Integerpublic static void main(String[] args) {AtomicInteger ac = new AtomicInteger();System.out.println(ac);AtomicInteger ac2 = new AtomicInteger(10);System.out.println(ac2);}
}

成员方法

方法名说明
int get()获取值
int getAndIncrement()以原子方式将当前值加1，注意，这里返回的是自增前的值
int incrementAndGet()以原子方式将当前值加1，注意，这里返回的是自增后的值
int addAndGet(int data)以原子方式将输入的数值与实例中的值（AtomicInteger里的value）相加，并返回结果
int getAndSet(int value)以原子方式设置为newValue的值，并返回旧值
package com.threadatom2;import java.util.concurrent.atomic.AtomicInteger;public class MyAtomIntegerDemo2 {
//    int get()	获取值
//    int getAndIncrement()	以原子方式将当前值加1，注意，这里返回的是自增前的值
//    int incrementAndGet()	以原子方式将当前值加1，注意，这里返回的是自增后的值
//    int addAndGet(int data)	以原子方式将输入的数值与实例中的值（AtomicInteger里的value）相加，并返回结果
//    int getAndSet(int value)	以原子方式设置为newValue的值，并返回旧值public static void main(String[] args) {
//        AtomicInteger ac1 = new AtomicInteger(10);
//        System.out.println(ac1.get());//        AtomicInteger ac2 = new AtomicInteger(10);
//        int andIncrement = ac2.getAndIncrement();
//        System.out.println(ac2.get());//        AtomicInteger ac3 = new AtomicInteger(10);
//        int i = ac3.incrementAndGet();
//        System.out.println(i);//自增后的值
//        System.out.println(ac3.get());//        AtomicInteger ac4 = new AtomicInteger(10);
//        int i = ac4.addAndGet(20);
//        System.out.println(i);
//        System.out.println(ac4.get());AtomicInteger ac5 = new AtomicInteger(10);int andSet = ac5.getAndSet(20);System.out.println(andSet);System.out.println(ac5.get());}
}

4.AtomicInteger内存解析

这时再来修改上面卖冰激凌的代码

package com.threadatom;import java.util.concurrent.atomic.AtomicInteger;public class MyAtomThread implements Runnable{//private int count = 0; //送冰激凌的数量//private Object lock = new Object();AtomicInteger ac = new AtomicInteger(0);@Overridepublic void run() {for (int i = 0; i < 100; i++) {//1.从共享数据中读取数据到本线程栈中//2.修改本线程栈中变量副本的值//3.会把本线程栈中变量副本的值赋值给共享数据//synchronized (lock) {//count++;int count = ac.incrementAndGet();System.out.println("已经送了"+count+"个冰激凌");//}}}
}

package com.threadatom;public class AtomDemo {public static void main(String[] args) {MyAtomThread atom = new MyAtomThread();for (int i = 0; i < 100; i++) {new Thread(atom).start();}}
}

自旋锁+CAS算法

CAS算法：

在修改共享数据的时候，把原来的旧值记录下来了

如果现在内存中的值跟原来的旧值一样，证明没有其他线程操作过内存值，则修改成功

如果现在内存中的值跟原来的旧值不一样了，证明已经有其他线程操作过内存值了

则修改失败，需要获取现在最新的值，再次进行操作，这个重新获取就是自旋

AtomicInteger源码解析

5.乐观锁和悲观锁

synchronized和CAS的区别

相同点：在多线程情况下，都可以保证共享数据的安全性

不同点：synchronized总是从最坏的角度出发，认为每次获取数据的时候，别都有可能修改。所以在每次操作共享数据之前，都会上锁。（悲观锁）

cas是从乐观的角度出发，假设每次获取数据别人都不会修改，所以不会上锁。只不过在修改共享数据的时候，会检查一下，别人有没有修改过这个数据

如果别人修改过，那么我再次获取现在最新的值

如果别人没有修改过，那么我现在直接修改共享数据的值。（乐观锁）

3.并发工具类

1.Hashtable

HashMap是线程不安全的（多线程环境下可能会存在问题）

为了保证数据的安全性我们可以使用Hashtable，但是Hashtable效率低下

package com.mymap;import java.util.Hashtable;public class MyHashtableDemo {public static void main(String[] args) throws InterruptedException {Hashtable<String, String> hm = new Hashtable<>();Thread t1 = new Thread(()->{for (int i = 0; i < 25; i++) {hm.put(i+"",+i+"");}});Thread t2 = new Thread(()->{for (int i = 25; i < 51; i++) {hm.put(i+"",+i+"");}});t1.start();t2.start();System.out.println("--------");//为了t1和t2能把数据全部添加完毕Thread.sleep(1000);//0-0 1-1 ... 50-50for (int i = 0; i < 51; i++) {System.out.println(hm.get(i+""));}//0 1 2 3 ... 50}
}

1.Hashtable采取悲观锁synchronized的形式保证数据的安全性

2.只要有线程访问，会将整张表全部锁起来，所以Hashtable效率低下

2.ConcurrentHushMap

package com.mymap;import java.util.Hashtable;
import java.util.concurrent.ConcurrentHashMap;public class MyConcurrentHashMapDemo {public static void main(String[] args) throws InterruptedException {ConcurrentHashMap<String, String> hm = new ConcurrentHashMap<>();Thread t1 = new Thread(()->{for (int i = 0; i < 25; i++) {hm.put(i+"",+i+"");}});Thread t2 = new Thread(()->{for (int i = 25; i < 51; i++) {hm.put(i+"",+i+"");}});t1.start();t2.start();System.out.println("--------");//为了t1和t2能把数据全部添加完毕Thread.sleep(1000);//0-0 1-1 ... 50-50for (int i = 0; i < 51; i++) {System.out.println(hm.get(i+""));}//0 1 2 3 ... 50}
}

1.Hashtable采取悲观锁synchronized的形式保证数据的安全性

2.只要有线程访问，会将整张表全部锁起来，所以Hashtable效率低下

3.ConcurrentHushMap也是线程安全的，效率较高

在JDK7和JDK8中，底层原理不一样

3.ConcurrentHushMap原理解析

1.7版本解析

创建对象

1.创建一个默认长度16，默认加载因为0.75的数组，数组名Segment

2.再创建一个长度为2的小数组，把地址值赋值给0索引，其他索引都是null

添加

第一次会根据键的哈希值计算出Segment数组（大数组）中应存入的位置

如果为null，就会按照模板创建一个长度默认为2的数组

创建完毕，会二次哈希，计算出在小数组中应存入的位置

直接存入

如果不为null，就会根据记录的地址值找到小数组

二次哈希，计算出在小数组中应存入的位置

如果需要扩容，则将小数组扩容两倍

如果不需要扩容，则就会看小数组的这个位置有没有元素

如果没有元素，则直接存入

如果有元素，就会调用equals方法，比较属性值

如果equals为true，则不存

如果equals为false，会形成哈希桶结构

1.8版本解析

底层结构：哈希表（数组，链表，红黑树的结合体）

结合CAS机制+synchronized同步代码块形式保证线程安全

1.如果使用空参构造创建ConcurrentHushMap对象，则什么事情都不做

在第一次添加元素的时候创建哈希表

2.计算当前元素应存入的索引

3.如果该索引位置为null，则采用cas算法，将本结点添加到数组中

4.如果该索引位置不为null，则利用volatile关键字获得当前位置最新的结点地址，挂在他下面，变成链表

5.当链表的长度大于等于8时，自动转换成红黑树

6.以链表或者红黑树头结点为锁对象，配合悲观锁保证多线程操作集合时数据的安全性

4.CountDownLatch

方法解释

public CountDownLatch(int count)

参数传递线程数，表示等待线程数量
public void await()让线程等待
public void countDown()当前线程执行完毕
package com.mycountdownlatch;import java.util.concurrent.CountDownLatch;public class MotherThread extends Thread{private CountDownLatch countDownLatch;public MotherThread(CountDownLatch countDownLatch) {this.countDownLatch = countDownLatch;}@Overridepublic void run(){//1.等待try {//当计数器变成0的时候，会自动唤醒这里等待的线程countDownLatch.await();} catch (InterruptedException e) {throw new RuntimeException(e);}//2.收拾碗筷System.out.println("妈妈在收拾碗筷");}
}

package com.mycountdownlatch;import java.util.concurrent.CountDownLatch;public class ChildThread1 extends Thread{private CountDownLatch countDownLatch;public ChildThread1(CountDownLatch countDownLatch) {this.countDownLatch = countDownLatch;}@Overridepublic void run(){//1.吃饺子for (int i = 1; i <= 10; i++) {System.out.println(getName()+"在吃第"+i+"个饺子");}//2.吃完说一声//每一次countDown方法的时候，就让计数器-1countDownLatch.countDown();}
}

package com.mycountdownlatch;import java.util.concurrent.CountDownLatch;public class ChildThread2 extends Thread{private CountDownLatch countDownLatch;public ChildThread2(CountDownLatch countDownLatch) {this.countDownLatch = countDownLatch;}@Overridepublic void run(){//1.吃饺子for (int i = 1; i <= 15; i++) {System.out.println(getName()+"在吃第"+i+"个饺子");}//2.吃完说一声countDownLatch.countDown();}
}

package com.mycountdownlatch;import java.util.concurrent.CountDownLatch;public class ChildThread3 extends Thread{private CountDownLatch countDownLatch;public ChildThread3(CountDownLatch countDownLatch) {this.countDownLatch = countDownLatch;}@Overridepublic void run(){//1.吃饺子for (int i = 1; i <= 20; i++) {System.out.println(getName()+"在吃第"+i+"个饺子");}//2.吃完说一声countDownLatch.countDown();}
}

package com.mycountdownlatch;import java.util.concurrent.CountDownLatch;public class MyCountDownLatchDemo {public static void main(String[] args) {//1.创建CountDownLatch的对象，需要传递给四个线程//在底层就定义了一个计数器，此时计数器的值就是3CountDownLatch countDownLatch = new CountDownLatch(3);//2.创建四个线程对象并开启他们MotherThread motherThread = new MotherThread(countDownLatch);motherThread.start();ChildThread1 t1 = new ChildThread1(countDownLatch);t1.setName("小明");ChildThread2 t2 = new ChildThread2(countDownLatch);t2.setName("小红");ChildThread3 t3 = new ChildThread3(countDownLatch);t3.setName("小刚");t1.start();t2.start();t3.start();}
}

使用场景：

让某一条线程等待其他线程执行完毕之后再执行

CountDownLatch(int count):参数与等待线程的数量。并定义了一个计数器

await()：让线程等待，当计数器为0时，会唤醒等待的线程

countDown():线程执行完毕时调用，会将计数器-1

5.Semaphore

使用场景：

可控制访问特定资源的线程数量

步骤：

1.需要有人管理这个通道    ---    创建Semaphore对象

2.当有车进来了，发通行许可证    ---    acquire()发通行证

3.当车出去了，收回通行许可证    ---    release()收回通行证

4.如果通行许可证发完了，那么其他车辆只能等着

package com.mysemaphore;import java.util.concurrent.Semaphore;public class MyRunnable implements Runnable{//1.获得管理员对象private Semaphore semaphore = new Semaphore(2);@Overridepublic void run() {//2.获得通行证try {semaphore.acquire();//3.开始行使System.out.println("获得了通行证开始行驶");Thread.sleep(2000);System.out.println("归还通行证");//4.归还通行证semaphore.release();} catch (InterruptedException e) {throw new RuntimeException(e);}}
}

package com.mysemaphore;public class MySemaphoreDemo {public static void main(String[] args) {MyRunnable mr = new MyRunnable();for (int i = 0; i < 100; i++) {new Thread(mr).start();}}
}

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

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

相关文章

观其大略之HybridCLR学习笔记

观其大略之HybridCLR学习笔记

问题背景 1 现有热更方案的开发效率、性能没有到达极限&#xff0c;还有提升的空间 2 ios多平台政策导致热更新受限问题&#xff0c;ios禁止jit。根据我查找的资料&#xff0c;ios的代码段启动的时候就确定了&#xff0c;不能增加新的代码段。IOS封了内存&#xff08;或者堆&…
阅读更多...
2024软件测试工具测评，总有一款适合你！

2024软件测试工具测评，总有一款适合你！

在软件开发周期中&#xff0c;测试是确保产品质量的关键环节。随着企业对于软件质量的要求日益提升&#xff0c;测试人员面临着前所未有的挑战&#xff0c;“工欲善其事必先利其器”&#xff0c;选择一款高效、实用的软件测试工具&#xff0c;不仅能够提升测试效率&#xff0c;…
阅读更多...
【比较mybatis、lazy、sqltoy、mybatis-flex、easy-query、mybatis-mp操作数据】操作批量新增、分页查询（四）

【比较mybatis、lazy、sqltoy、mybatis-flex、easy-query、mybatis-mp操作数据】操作批量新增、分页查询（四）

orm框架使用性能比较 比较mybatis、lazy、sqltoy、mybatis-flex、easy-query、mybatis-mp操作数据 环境&#xff1a; idea jdk17 spring boot 3.0.7 mysql 8.0测试条件常规对象 orm 框架是否支持xml是否支持 Lambda对比版本编码方式mybatis☑️☑️3.5.4lambda xml 优化sq…
阅读更多...
嘉绩咨询：搭建品牌招商桥梁，提供卓越讲师与会议服务

嘉绩咨询：搭建品牌招商桥梁，提供卓越讲师与会议服务

当下&#xff0c;品牌成功的关键在于强大的渠道支撑和高效的招商能力&#xff0c;在这一背景下&#xff0c;嘉绩咨询&#xff0c;这一专注于渠道招商全案系统孵化的知名平台型企业&#xff0c;今日宣布&#xff0c;将进一步加强其在品牌招商桥梁搭建上的服务功能&#xff0c;通…
阅读更多...
[java] 23种设计模式之桥接模式

[java] 23种设计模式之桥接模式

一、什么是桥接模式 桥接(Bridge)模式属于结构型设计模式。通过提供抽象化和实现化之间的桥接结构&#xff0c;来实现二者的解耦。把抽象(abstraction)与行为实现(implementation)分离开来&#xff0c;从而可以保持各部分的独立性以及应对它们的功能扩展。 二、适用场景 当一…
阅读更多...
不知道吧，腾讯云轻量应用服务器使用有一些限制！

不知道吧，腾讯云轻量应用服务器使用有一些限制！

腾讯云轻量应用服务器相对于云服务器CVM是有一些限制的&#xff0c;比如轻量服务器不支持更换内网IP地址&#xff0c;不支持自定义私有网络VPC&#xff0c;内网连通性方面也有限制&#xff0c;轻量不支持CPU内存、带宽或系统盘单独升级&#xff0c;只能整个套餐整体升级&#x…
阅读更多...
Intellij IDEA 中 git 操作的快捷键

Intellij IDEA 中 git 操作的快捷键

1.添加新建的文件 即add 操作 shift alt a 2.提交操作 即 commit操作 ctrl k 在窗口中可以用feature来声明此次更新的内容 3.提交操作 即push操作 ctrl shift k 4.拉去远程分支操作 即pull操作 ctrl t
阅读更多...
一个爬虫自动化数据采集的故事~

一个爬虫自动化数据采集的故事~

目录 一、原文二、故事前半段背景内容三、正经的讲点DrissionPage知识四、故事的收尾 一、原文 原文来自一个爬虫自动化数据采集的故事~ , 建议点击链接看文章末尾的视频笔者不擅长自动化&#xff0c;一个小小故事分享给大家&#xff0c;仅个人观点 二、故事前半段背景内容 …
阅读更多...
【C语言】linux内核tcp_write_xmit和tcp_write_queue_purge

【C语言】linux内核tcp_write_xmit和tcp_write_queue_purge

tcp_write_xmit 一、讲解 这个函数 tcp_write_xmit 是Linux内核TCP协议栈中的一部分&#xff0c;其基本作用是发送数据包到网络。这个函数会根据不同情况推进发送队列的头部&#xff0c;确保只要远程窗口有空间&#xff0c;就可以发送数据。 下面是对该函数的一些主要逻辑的中…
阅读更多...
python爬虫（4）

python爬虫（4）

#前期先说明一下为啥爬虫需要学习数组的存储和处理&#xff0c;只是说在你后期接触到最简单的爬虫后有一个地方可以存放你的数据# 下面为大家带来一个我在做excel表整理时的代码以及上次代码的结果 上次代码的结果&#xff1a; 新的代码&#xff1a; import numpy as np im…
阅读更多...
委员建议进一步扩大香港与内地金融市场互联互通发展

委员建议进一步扩大香港与内地金融市场互联互通发展

在我们共同追寻金融发展的星辰大海之际&#xff0c;我怀着无比激动的心情&#xff0c;向诸位委员提议进一步扩大香港与内地金融市场互联互通发展。这个议题犹如一颗璀璨的明珠&#xff0c;闪耀着诱人的光芒&#xff0c;吸引着我们为之奋斗。让我们共同探讨这一话题&#xff0c;…
阅读更多...
如何变得心智成熟？我推荐你读这5本书

如何变得心智成熟？我推荐你读这5本书

一个人若总是在底层混&#xff0c;说明他的脑子确实不怎么样&#xff0c;一群底层的人聚在一起就更完蛋。 变化是常态&#xff0c;成长是选择。无法否定过去相信的东西&#xff0c;是你最大的障碍。 今天&#xff0c;为大家推荐一份“心智书单”。 01 《打开心智》 李睿秋提…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023