多线程-线程安全学习笔记

最新推荐文章于 2022-06-26 15:28:35 发布
最新推荐文章于 2022-06-26 15:28:35 发布
阅读量94 收藏
点赞数
分类专栏： java 文章标签： 多线程 java 并发编程 线程安全 线程池
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lkiiiojlkm/article/details/117535286
版权

线程安全

一、概述

1.资源复用

在这里插入图片描述

2.死锁
（1）概念：

多个线程各自占有一些共享资源，并且互相等待其它线程占有的资源才能运行，而导致两个或者多个线程都在等待对方释放资源，都停止执行的情形。某一个同步块同时拥有 “两个以上对象的锁” 时,就可能会发生 “死锁” 的问题。

小提示：想保证资源唯一，定义成 Static 即可。

（2）产生死锁的四个必要条件:
  1. 互斥条件 : 一个资源每次只能被一个进程使用。
  2. 请求与保持条件 : 一个进程因请求资源而阻塞时，对已获得的资源保持不放。
  3. 不剥夺条件 : 进程已获得的资源，在末使用完之前，不能强行剥夺。
  4. 循环等待条件 : 若干进程之间形成一种头尾相接的循环等待资源关系。

上面列出了死锁的四个必要条件，我们只要想办法破其中的任意一个或多个条件就可以避免死锁发生。

二、出现线程安全的例子

public class RunnableImpl implements Runnable{
    //定义一个多线程共享的票源
    private int ticket = 100;
    //设置线程任务;卖票
    @Override
    public void run() {
        //使用死循环,让卖票操作重复执行
        while (true) {
            if (ticket>0){
                //提高安全问题出现的概率,让程序睡眠
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName()+"线程正在卖第"+ticket+"张票");
                ticket--;
            }
        }
    }
}

 public static void main(String[] args) {
        RunnableImpl runnable = new RunnableImpl();
        Thread thread1 = new Thread(runnable);
        Thread thread2 = new Thread(runnable);
        Thread thread3 = new Thread(runnable);
        thread1.start();
        thread2.start();
        thread3.start();//会出现线程安全问题
    }

分析:

在这里插入图片描述

三、线程同步

当我们使用多个线程访问同一资源的时候，且多个线程中对资源有写的操作，就容易出现线程安全问题。要解决上述多线程并发访问一个资源的安全性问题:也就是解决重复票与不存在票问题，Java中提供了同步机制(synchronized)来解决。
根据案例简述︰

窗口1线程进入操作的时候，窗口2和窗口3线程只能在外等着，窗口1操作结束，窗口1和窗口2和窗口3才有机会进入代码去执行。也就是说在某个线程修改共享资源的时候，其他线程不能修改该资源，等待修改完毕同步之后，才能去抢夺CPU资源，完成对应的操作，保证了数据的同步性，解决了线程不安全的现象。

​ 为了保证每个线程都能正常执行原子操作Java引入了线程同步机制。那么怎么去使用呢?

有三种方式完成同步操作︰

​ 1.同步代码块。

​ 2.同步方法。

​ 3.锁机制。

1、同步代码块
  • 同步代码块: synchronized关键字可以用于方法中的某个区块中，表示只对这个区块的资源实行互斥访问。

格式 :

synchronized(同步锁){
	需要同步操作的代码
}
注意:
  1.通过代码块中的锁对象,可以使用任意的对象
  2.但是必须保证多个线程使用的锁对象是同一个
  3.锁对象作用: 把同步代码块锁住,只让一个线程在同步代码块中执行

同步锁 :

对象的同步锁只是一个概念,可以想象为在对象上标记了一个锁.

  1. 锁对象可以是任意类型。
  2. 多个线程对象要使用同一把锁.
    • 注意:在任何时候,最多允许一个线程拥有同步锁,谁拿到锁就进入代码块,其他的线程只能在外等着(BLOCKED)。

使用同步代码块解决代码(示例)∶

//同步代码块
synchronized (m_object){
    if (ticket>0){
        //提高安全问题出现的概率,让程序睡眠
        try {
       		 Thread.sleep(10);
        } catch (InterruptedException e) {
       		 e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName()+"线程正在卖第"+ticket+"张票");
        ticket--;
     }
}

同步技术的原理：

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

2.同步方法

同步方法 : 使用synchronized修饰的方法,就叫做同步方法,保证A线程执行该方法的时候,其他线程只能在方法外等着。

//格式
public synchronized void method(){
	可能会产生线程安全问题的代码
}

同步锁是谁?
对于非 static 方法,同步锁就是 this。
对于 static方法, 我们使用当前方法所在类的字节码对象(类名.class)。

3、Lock锁

java.util.concurrent.locks.Lock’机制提供了比 synchronized 代码块和 synchronized 方法更几泛的锁定操作,同步代码块/同步方法具有的功能 Lock 都有,除此之外更强大,更体现面向对象。

使用步骤：

​ 1.在成员位置创建一个ReentrantLock 类 对象

​ 2.在可能会出现安全问题的代码前调用Lock接口中的Lock( )方法 获取锁

​ 3.在可能会出现安全问题的代码后调用Lock接口中的unLock( )方法 释放锁

Lock锁也称同步锁，加锁与释放锁方法化了，如下:

public void lock() //加同步锁。
public void unlock()//释放同步锁。
4、synchronized 与 Lock 的对比
  • Lock是显式锁（手动开启和关闭锁，别忘记关闭锁), synchronized是隐式锁，出了作用域自动释放。
  • Lock只有代码块锁,synchronized有代码块锁和方法锁。
  • 使用Lock锁，JVM将花费较少的时间来调度线程，性能更好。并且具有更好的扩展性（提供更多的子类)
  • 优先使用顺序
    • Lock > 同步代码块（已经进入了方法体，分配了相应资源) > 同步方法（在方法体之外)

四、线程间通信

一、概念
  1. 多个线程在处理同一个资源，但是处理的动作（线程的任务)却不相同。
    • 比如∶线程A用来生成包子的，线程B用来吃包子的，包子可以理解为同一资源，线程A与线程B处理的动作，一个是生产，一个是消费，那么线程A与线程B之间就存在线程通信问题。
  2. 为什么要处理线程间通信？
    • 多个线程并发执行时,在默认情况下CPU是随机切换线程的，当我们需要多个线程来共同完成一件任务，并且我们希望他们有规律的执行,那么多线程之间需要一些协调通信，以此来帮我们达到多线程共同操作一份数据。
  3. 如何保证线程间通信有效利用资源？
    • 多个线程在处理同一个资源，并且任务不同时，需要线程通信来帮助解决线程之间对同一个变星的使用或操作。就是多个线程在操作同一份数据时，避免对同一共享变量的争夺。也就是我们需要通过一定的手段使各个线程能有效的利用资源。而这种手段即—―等待唤醒机制。
二、线程状态概述

当线程被创建并启动以后，它既不是一启动就进入了执行状态，也不是一直处于执行状态。在线程的生命周期中，有几种状态呢?在API中 java.lang.Thread.State这个枚举中给出了六种线程状态∶

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

我们不需要去研究这几种状态的实现原理，我们只需知道在做线程操作中存在这样的状态。那我们怎么去理解这几个状态呢，新建与被终止还是很容易理解的，我们就研究一下线程从Runnable(可运行）状态与非运行状态之间的转换问题。

1、计时等待

在这里插入图片描述

2、锁阻塞

在这里插入图片描述

3、实现计时等待的方式
一、使用 synchronized 关键字 + Object类的方法

进入到Timewaiting(计时等待)有两种方式 ：

  • 使用sleep(Long m)方法,在毫秒值结束之后,线程睡醒进入到Runnable/Blocked状态
  • 使用wait(Long p)方法, wait方法如果在毫秒值结束之后,还没有被not ify唤醒,就会自动醒来,线程睡醒进入到Runnable/BLocked状态。

唤醒的方法 :

  • void notify() 唤醒在此对象监视器上等待的单个线程。
  • void notifyALL() 唤醒在此对象监视器上等待的所有线程。

生产者消费者模型 常用解决方法 ：

  • 利用缓冲区–即消息队列 解决（管程法）
  • 利用标志位解决 (信号灯法)

例子：

/**
 * @ClassName:PCtest
 * @创建者: LLY
 * @创建时间: 2021/5/9 22:00
 * @version: 1.0
 * @描述: 生产者消费者模型 ->利用缓冲区解决（管程法）
 * 只有锁对象才能调用wait和notify方法
 * Object类中的方法
 *  void wait()  在其他线程调用此对象的notify()方法或notifyAll()方法前，导致当前线程等待。
 *  void notify() 唤醒在此对象监视器上等待的单个线程。会继续执行wait方法之后的代码
 */

// 生产者、消费者、产品、仓库(缓冲区)
public class PCtest {
    public static void main(String[] args) {
        Warehouse warehouse = new Warehouse();
        new Producter(warehouse).start();
        new Consumer(warehouse,"顾客1").start();
    }
}

//生产者
class Producter extends Thread{

    Warehouse warehouse = new Warehouse();

    public Producter(Warehouse warehouse) {
        this.warehouse = warehouse;
    }

    @Override
    public void run() {
        //总共做100件产品
        for (int i = 1; i <= 100; i++) {
            Product product = new Product(i, "烤鸭");
            try {
                warehouse.push(product);
                System.out.println("生产者烤好了第"+i+"只烤鸭！");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

//消费者
class Consumer extends Thread{

    Warehouse warehouse = new Warehouse();

    public Consumer(Warehouse warehouse,String name) {
        super(name);
        this.warehouse = warehouse;
    }
    
    @Override
    public void run() {

        for (int i = 1; i <= 100; i++) {
            try {
                Product product = warehouse.pop();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+"吃了第"+i+"只烤鸭！");
        }
    }
}

//产品
class Product{

    Integer ID;//产品编号
    String Pname;//产品名称

    public Product(Integer ID, String pname) {
        this.ID = ID;
        Pname = pname;
    }
}

//仓库(缓冲区)
class Warehouse{

    Product[] products = new Product[10];
    Integer count = 0;

    //放入仓库
    public synchronized void push(Product p) throws InterruptedException {
        //如果仓库满了，就通知消费者线程消费，自身等待。
        if (count == products.length-1){
            this.wait();
        }
        products[count] = p;
        count++;
        this.notifyAll();
    }

    //拿出仓库
    public synchronized Product pop() throws InterruptedException {
        if (count == 0) {
            this.wait();
        }
        count--;
        Product product = products[count];
        this.notifyAll();
        return product;
    }
}

/**
 * @ClassName:PCtest2
 * @创建者: LLY
 * @创建时间: 2021/5/10 11:02
 * @version: 1.0
 * @描述:生产者消费者模型 -> 标志位解决 (信号灯法)
 */
public class PCtest2 {
    public static void main(String[] args) {
        TV tv = new TV();
        new Player(tv).start();
        new Watcher(tv).start();
    }
}

//生产者
class Player extends Thread{
    TV m_tv;
    public Player(TV tv) {
        m_tv = tv;
    }

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            try {
                if ( i % 5 > 2)
                    m_tv.show("相声");
                else
                    m_tv.show("广告");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

//消费者
class Watcher extends Thread{
    TV m_tv;
    public Watcher(TV tv) {
        m_tv = tv;
    }

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            try {
                m_tv.watch();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

//产品
class TV{
    boolean flag = true; // T 没有节目, F 有节目
    String mv;//节目名称

    public synchronized void show(String mv) throws InterruptedException {
        //有节目，通知观众看
        if (!flag){
            this.wait();
        }
        //演员录节目，观众等待
        System.out.println("录制好了！"+mv);
        this.mv = mv;
        this.notifyAll();
        this.flag = !this.flag;
    }

    //节目录好，观众观看，演员休息
    public synchronized void watch() throws InterruptedException {
        if (flag){
            this.wait();
        }
        System.out.println("观看完了！"+this.mv);
        this.notifyAll();
        this.flag = !this.flag;
    }
}
二、使用 Lock 锁 + condition

Condition是在 java 1.5中才出现的，它用来替代传统的Object的wait()、notify()实现线程间的协作，相比使用Object的wait()、notify()，使用Condition的await()、signal()这种方式实现线程间协作更加安全和高效。因此通常来说比较推荐使用Condition，阻塞队列实际上是使用了Condition来模拟线程间协作。

Condition是个接口，基本的方法就是await()和signal()方法；

Condition依赖于Lock接口，生成一个Condition的基本代码是lock.newCondition()。

调用Condition的await()和signal()方法，都必须在lock保护之内，就是说必须在lock.lock()和lock.unlock之间才可以使用。

  • Conditon中的await()对应Object的wait()；
  • Condition中的signal()对应Object的notify()；
  • Condition中的signalAll()对应Object的notifyAll()。

例子

public class ConTest {
	
	 final Lock lock = new ReentrantLock();
	 final Condition condition = lock.newCondition();
 
	public static void main(String[] args) {
		ConTest test = new ConTest();
	    Producer producer = test.new Producer();
	    Consumer consumer = test.new Consumer();
	           
	    consumer.start(); 
	    producer.start();
	}
	
	 class Consumer extends Thread{
         
	        @Override
	        public void run() {
	            consume();
	        }
	          
	        private void consume() {	           	             
	                try {
	                	   lock.lock();
	                    System.out.println("我在等一个新信号"+this.currentThread().getName());
	                    condition.await();
	                    
	                } catch (InterruptedException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					} finally{
						System.out.println("拿到一个信号"+this.currentThread().getName());
	                    lock.unlock();
	                }
	            
	        }
	    }
	 
	 class Producer extends Thread{
         
	        @Override
	        public void run() {
	            produce();
	        }
	          
	        private void produce() {	             
	                try {
	                	   lock.lock();
	                       System.out.println("我拿到锁"+this.currentThread().getName());
	                       condition.signalAll();	                         
	                    System.out.println("我发出了一个信号："+this.currentThread().getName());
	                } finally{
	                    lock.unlock();
	                }
	            }
	 }    
}

注意：

哪怕只通知了一个等待的线程，被通知线程也不能立即恢复执行，因为它当初中断的地方是在同步块内，而此刻它已经不持有锁，所以她需要再次尝试去获取锁(很可能面临其它线程的竞争），成功后才能在当初调用wait方法之后的地方恢复执行。

总结如下 :

  • 如果能获取锁，线程就从WAITING状态变成 RUNNABLE状态
  • 否则，从wait set出来，又进入entry set，线程就从WAITING 状态又变成BLOCKED状态

调用wait和notify方法需要注意的细节

  1. wait方法与notify方法必须要由同一个锁对象调用。因为∶对应的锁对象可以通过notify唤醒使用同一个锁对象调用的wait方法后的线程。
  2. wait方法与notify方法是属于Object类的方法的。因为︰锁对象可以是任意对象，而任意对象的所属类都是继承了Object类的。
  3. wait方法与notify方法必须要在同步代码块或者是同步函数中使用。因为∶必须要通过锁对象调用这2个方法。

五、线程池(简述)

详细 叙述 参照 JAVA进阶之JUC并发编程

一、概述

线程池∶其实就是一个容纳多个线程的容器，其中的线程可以反复使用，省去了频繁创建线程对象的操作，无需反复创建线程而消耗过多资源。
由于线程池中有很多操作都是与优化资源相关的，我们在这里就不多赘述。

在这里插入图片描述

我们通过一张图来了解线程池的工作原理 :

在这里插入图片描述

合理利用线程池能够带来三个好处︰

  1. 降低资源消耗。减少了创建和销毁线程的次数，每个工作线程都可以被重复利用，可执行多个任务。
  2. 提高响应速度。当任务到达时，任务可以不需要的等到线程创建就能立即执行。
  3. 提高线程的可管理性。可以根据系统的承受能力，调整线程池中工作线线程的数目，防止因为消耗过多的内存，而把服务器累趴下(每个线程需要大约1MB内存，线程开的越多，消耗的内存也就越大，最后死机

二、使用

ExecutorService : 真正的线程池接口。常见子类 ThreadPoolExecutor【推荐使用】。

使用在 java.util.concurrent.Executors 线程工厂类里面提供了一些静态工厂，生成一些常用的线程。

Executors : 线程池工具类、线程池的工厂类，用于创建并返回不同类型的线程池

创建线程池的方法如下∶

​ public static ExecutorService newFixedThreadPool(int nThreads) : 返回线程池对象。

​ (创建的是有界线程池,也就是池中的线程个数可以指定最大数量)

使用线程池对象的方法如下:

  • void execute(Runnable command) : 执行任务/命令，没有返回值，一般用来执行 Runnable
  • Futuresubmit(Callable task) : 执行任务，有返回值，一般用来执行 Callable
  • void shutdown() : 关闭线程池

使用步骤 :

  1. 创建线程池对象。
  2. 创建Runnable接口子类对象。
  3. 提交Runnable接口子类对象。(take task)
  4. 关闭线程池(一般不做)。

例子：

public class RunnableImpl implements Runnable{
    @Override
    public void run() {
        System.out.println("线程名称为:"+Thread.currentThread().getName()+"产生了一个新线程！");
    }
}

public static void main(String[] args) {
//1、使用线程池的工厂类 Executors 提供的静态方法newFixedThreadPool()生产一个指定线程数量的线程池
    ExecutorService ex = Executors.newFixedThreadPool(2);
//3、调用Executors中的方法submit()，传递线程任务(实现类)，开启线程，执行线程任务。
    ex.submit(new RunnableImpl());
    ex.submit(new RunnableImpl());
    ex.submit(new RunnableImpl());
}
飘渺`轩辕
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
JAVA并发编程实践-线程安全-学习笔记
07-20
线程安全就是对共享的、可变的状态进行管理，对象的状态就是它的数据，换句话说就是在不可控制的并发访问中保护数据。
线程学习总结
qq_47499256的博客
11-21 335
1.线程和进程 1.1进程的概念 进程就是正在运行的程序,它会占用对应的内存区域，由CPU进行执行与计算。 1.2线程的概念 线程是操作系统OS能够进行运算调度的最小单位,它被包含在进程之中,是进程中的实际运作单位. 1.3多线程并发和并行 并发：两个或多个事件在同一时间间隔发生。 并行：两个或者多个事件在同一时刻发生。 并行是真正意义上，同一时刻做多件事情，而并发在同一时刻只会做一件事件，只是可以将时间切碎，交替做多件事情。 网上有个例子挺形...
线程的学习
z184162946的博客
05-28 256
CPU难道真的很神通广大，能够同时执行那么多程序吗？不是的，CPU的执行是这样的：CPU的速度很快，一秒钟可以算好几亿次，因此CPU把自己的时间分成一个个小时间片，我这个时间片执行你一会，下一个时间片执行他一会，再下一个时间片又执行其他人一会，虽然有几十个线程，但一样可以在很短的时间内把他们通通都执行一遍，但对我们人来说，CPU的执行速度太快了，因此看起来就像是在同时执行一样，但实际上在一个时间点上，CPU只有一个线程在运行。 学习线程首先要理清楚三个概念： 进程：进程是一个静态的概念 线程：一个进
线程的学习——基本知识
weixin_61050264的博客
02-08 264
/** * 基础知识： * 线程：线程与进程相似，是一段完成某个特定功能的代码，是程序中单个顺序控制的流程，但与进程不同的 * 是，同类的多个线程是共享一块内存空间和一组系统资源。所以系统在各个线程之间切换时，开销要 * 比进程小的多，正因如此，线程被称为轻量级进程。一个进程中可以包含多个线程。 * 主线程： * Java程序至少会有一个线程，这就是主线程，程序启动后是由JVM创建主线程，程序结束时由JVM停 * 止主线程。主线程它负责管理子线.
多线程-狂神说Java学习笔记
最新发布
07-19
狂神说Java学习笔记（笔记+源代码+图片)—多线程
多线程学习笔记
03-18
多线程学习笔记，通过平时的学习所做的一些笔记，希望对广大同仁有所帮助
JUC多线程学习个人笔记
07-08
并发集合：JUC提供了一些线程安全的集合类，如ConcurrentHashMap、ConcurrentLinkedQueue等，可以在多线程环境下安全地访问和修改集合。 原子操作：JUC提供了一些原子操作类，如AtomicInteger、AtomicLong等，可以...
多线程学习笔记.docx
06-16
包括线程和进程的关系，线程的三种创建方式，继承thread，实现runnable接口，实现callable接口，线程同步，生产者消费者模式
Java多线程学习（吐血超详细总结）
晨 の Java天堂
04-13 1934
链接地址 转自http://blog.csdn.net/evankaka
线程学习
supwuq的博客
03-06 112
上图是线程的状态转换示意图。之前感觉看文字描述的很简单理解，画了图就不记得了。 这里来理一下，其中 a=就绪 b= 阻塞 c=运行 理解是这样的，一个线程被初始化之后就是就绪的状态，等待着cpu来调度它，当被调用之后就进入运行状态， 这个时候，如果是cpu主动分配的时间片段到了，还没执行完，那么由运行进入就绪状态，等待下次调用。 但是因为cpu会同时处理很多请求，而这些...
线程安全--学习笔记
forcht
07-30 130
线程安全：当多个线程访问一个对象的时候，如果不用考虑这些线程在运行时环境下的调度和交替执行，也不需要进行额外的同步，或者在调度方进行其他的协调操作，调用这个对象的行为都可以获得正确的结果，那么这个对象即使线程安全的。 实现线程安全地方法： 加锁同步（悲观锁）： synchronized，ReentrantLock。 Synchronized的实现原理： java虚拟机是基于进入和退出的Mon...
多线程学习——入门篇
Gavin_Java_的博客
10-21 1116
前言：想成为一名优秀的程序员，线程这个重要的知识点一定要掌握。 一、什么是线程 进程（Process）是计算机中的程序关于某数据集合上的一次运行活动，是系统进行资源分配和调度的基本单位，是操作系统结构的基础。——百度百科 撇开调度不说，进程就是应用程序在内存中分配的空间，java启动main方法就是启动了一个JVM的进程，JVM内存模型如图，而main方法又是此进程中的一个线程，又称主线程。例：把内存比作一块地，春天了，赵家村要搞一次种地运动，村长为南区分配一块地，配置水源，工具区。张三兴致勃勃的去种
JAVA多线程学习心得（一）
去宇宙
04-07 4096
最近在github上写了几个关于多线程的练习， 项目地址：https://github.com/jndf/multithreading-pratice 需要的朋友可以看看，代码如有错误，请多提出指正意见。 下面说一下最近的一些心得。 Thread和Runnable两种实现方式。 这两种方法都是最基础的实现线程的方法，声明线程对象后，通过调用对象的start()方法，来执行线程内...
7、学习线程
y13379的专栏
04-10 231
学习容器： j2sdk所提供的容器api在java.util包内。 Collection。是容器的总称。 Map：一组成对的 键值对 对象，允许使用键来查找值。 List：有顺序的插入，可以重复。 ArrayList：读数据的速度快，改数据的速度慢。 LinkedList：改数据的速度快，读数据的速度慢。 set：没有顺序的插入，不可以重复。 栈 是后进先出的容器，LinkedLi
线程学习（一）
BIGGERLIU的博客
06-26 144
线程学习（一）
java多线程学习（上）
zone的博客
05-28 2125
说在前面，我自己是不喜欢看特别长篇的博客。我能理解看长篇博客的那种难受，因此，想直接入正题看编码的不妨跳过前两块内容，直接进入“线程的创建”。 线程概述 什么是线程？ 之前看到过某大神这样一句话：比较糟糕的技术文档的特征：用专业名词来解释专业名词 从这句话中，我受益匪浅，因此以后的文章尽量都避免这样。相信大家也不喜欢看一些概念性的东西吧。 介绍线程之前，首先得解释一下进程，因为要...
python文本预处理速度慢_学习笔记--python中使用多进程、多线程加速文本预处理...
05-15
为了加速文本预处理，可以使用多进程和多线程技术。 使用多进程： Python的multiprocessing模块可以帮助我们创建多个进程来并行执行任务。可以将数据集划分为多个子集，然后在每个子集上启动一个进程来处理。这样...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值