Java多线程基础学习

已于 2022-05-09 18:05:43 修改
阅读量221 收藏
点赞数
文章标签： 学习 java 开发语言
于 2022-05-09 17:33:49 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Akatsuki333/article/details/124671002
版权

进程、线程、多线程

1. 基本概念

进程，即程序的一次执行过程。

通常一个进程中可以包含若干个线程，一个进程中至少存在一个线程，线程是CPU调度和执行的单位。

在这里插入图片描述

PS：

  • 很多多线程是模拟出来的，真正的多线程是指有多个CPU，即多核，如服务器。模拟出来的多线程，即在一个CPU的情况下，同一个时间点，CPU只能执行一个代码，因为切换的很快，才有同时执行的错觉。
  • main()方法称之为主线程，为系统的入口，用于执行整个程序。
  • 程序运行时，即使没有自己创建线程，后台也会有多个线程，如主线程，gc线程。
  • 在一个进程中，如果开辟了多个线程，线程的运行由调度器安排调度，调度器是与操作系统紧密相关的，先后顺序是不能认为的干预的。
  • 对同一份资源操作时，会存在资源抢夺的问题，需要加入并发控制。
  • 线程会带来额外的开销，如CPU调度时间，并发控制开销。

2. 线程的创建

线程有三种创建方式

  • 继承Thread类，Thread类也实现了Runnable接口
  • 实现Runnable接口
  • 实现Callable接口(了解即可)

2.1 继承Thread创建线程

继承Thread类，重写run()方法，调用start()方法开启线程

package com.chen.demo1;

//创建线程方式一: 继承Thread类，重写run()方法，调用start()方法开启线程
//线程开启不一定立即执行，由CPU调度执行
public class TestThread1 extends Thread{
    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            System.out.println("run"+i);
        }
    }

    public static void main(String[] args) {
        //使用start调用线程    两个线程会交替执行
        TestThread1 testThread1 = new TestThread1();
        testThread1.start();

        for (int i = 0; i < 500; i++) {
            System.out.println("main方法"+i);
        }
    }
}

运行结果：

在这里插入图片描述

由运行结果可知，两个线程在一个CPU的调度下交替执行。

2.2 实现Runnable接口创建线程

实现Runnable接口可避免单继承的局限性，方便同一个对象被多个线程使用。

package com.chen.demo1;

//通过实现Runnable接口创建线程
public class TestThread2 implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            System.out.println("run"+i);
        }
    }

    public static void main(String[] args) {
        //创建线程对象，通过线程对象开启线程  代理
        TestThread2 testThread2 = new TestThread2();

        //Thread thread = new Thread(testThread2);
        //thread.start();
        new Thread(testThread2).start();


        for (int i = 0; i < 500; i++) {
            System.out.println("main方法"+i);
        }
    }
}

2.3 实现Callable接口创建线程

package com.chen.demo2;

import java.util.concurrent.*;

//通过实现Callable接口创建线程
/*
callable:
1.可以定义返回值
2.可以抛出异常
 */
public class TestCallable implements Callable<Boolean> {
    private int tickets = 10;
    @Override
    public Boolean call() {
        while (tickets > 0){

            //模拟延时
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }


            System.out.println(Thread.currentThread().getName()+"-->拿到了第"+tickets--+"票");
        }
        return true;
    }
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        TestCallable t1 = new TestCallable();
        TestCallable t2 = new TestCallable();
        TestCallable t3 = new TestCallable();

        //创建执行服务
        ExecutorService ser = Executors.newFixedThreadPool(3);
        //提交执行
        Future<Boolean> result1 = ser.submit(t1);
        Future<Boolean> result2 = ser.submit(t2);
        Future<Boolean> result3 = ser.submit(t3);
        //获取结果
        boolean r1 = result1.get();
        boolean r2 = result2.get();
        boolean r3 = result3.get();

        System.out.println(r1);
        System.out.println(r2);
        System.out.println(r3);
        //关闭服务
        ser.shutdown();
    }
}

3. 并发问题

模拟抢火车票

package com.chen.demo1;

//多个线程同时操作一个对象
//买火车票
public class TestThread3 implements Runnable{
    private int tickets = 10;

    @Override
    public void run() {
        while (true){
            //边界条件
            if (tickets <= 0){
                break;
            }

            //模拟网络延时：放大问题的发生性
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            System.out.println(Thread.currentThread().getName()+"-->拿到了第"+tickets--+"票");
        }
    }

    public static void main(String[] args) {
        TestThread3 thread3 = new TestThread3();
        //启动线程
        new Thread(thread3,"小明").start();
        new Thread(thread3,"小红").start();
        new Thread(thread3,"黄牛").start();
    }
}

运行结果：

在这里插入图片描述

由运行结果可知，当多个线程访问同一个对象，有可能会出现同一张票被不同的人同时拿到，即同一资源被同时分配给不同线程，这就是多线程的并发问题。

4.线程的状态、方法

在这里插入图片描述

一些线程的方法：

在这里插入图片描述

4.1 停止线程

  • 不推荐使用JDK提供的stop()、destroy()方法。【已过时】
  • 推荐线程自己停下来
  • 建议使用一个标志位用作终止变量，当flag=false，则终止线程运行。
package com.chen.state;

//测试stop
//1.建议线程正常停止--->利用次数,不建议死循环。
//2.建议使用标志位--->设置一个标志位
//3.不要使用stop或者destroy等过时或者JDK不建议使用的方法
public class TestStop implements Runnable{

    //1.设置一个标志位
    private boolean flag = true;

    @Override
    public void run() {
            int i = 0;
            while (flag){
                System.out.println("run...."+i++);
        }
    }

    //2.设置一个公开的方法停止线程，转换标志位
    public void stop(){
        this.flag = false;
    }

    public static void main(String[] args) {
        TestStop testStop = new TestStop();
        new Thread(testStop).start();
        for (int i = 0; i < 1000; i++) {
            System.out.println("main"+i);
            if (i == 900){
                //调用stop方法切换标志位，让线程在i=900时停止
                testStop.stop();
                System.out.println("线程停止");
            }
        }
    }
}

4.2 线程休眠_sleep()

  • sleep (时间)：指定当前线程阻塞的毫秒数。
  • sleep存在异常InterruptedException。
  • sleep时间达到后线程进入就绪状态。
  • sleep可以模拟网络延时，倒计时等。
  • 每一个对象都有一个锁，sleep不会释放锁。

模拟倒计时，5秒倒计时结束后每过一秒打印一次当前时间

package com.chen.state;
import java.util.Date;

//模拟倒计时 5秒倒计时结束后每过一秒打印一次当前时间
public class TestSleep {
    public static void main(String[] args) throws InterruptedException {
        tenDown();

        //每过一秒打印一次系统时间
        Date time;
        while (true){
            Thread.sleep(1000);
            time = new Date(System.currentTimeMillis());//将当前时间赋给time
            System.out.println(time);
        }
    }

    //5秒倒计时
    public static void tenDown() throws InterruptedException {
        int num = 5;
        while (true){
            Thread.sleep(1000);
            System.out.println(num--);
            if (num <= 0){
                break;
            }
        }
    }
}

4.3 线程礼让_yield()

  • 礼让线程，让当前正在执行的线程暂停，但不阻塞。
  • 将线程从运行状态转为就绪状态。
  • 让CPU重新调度，礼让不一定成功！看CPU心情。
package com.chen.state;

//测试礼让线程 礼让不一定成功 看CPU心情
public class TestYield {
    public static void main(String[] args) {
        MyYield myYield = new MyYield();
        new Thread(myYield,"a").start();
        new Thread(myYield,"b").start();
    }
}

class MyYield implements Runnable{
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"开始执行");
        Thread.yield();
        System.out.println(Thread.currentThread().getName()+"执行结束");
    }
}

运行结果：

  • 礼让失败

在这里插入图片描述

  • 礼让成功

在这里插入图片描述

4.4 线程插队_join()

  • join合并线程，待此线程执行完毕后，再执行其他线程，其他线程阻塞
  • 可以想象成插队
package com.chen.state;

//测试join方法  可以想象成插队
public class TestJoin implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 1000; i++) {
            System.out.println("线程VIP来啦"+i);
        }
    }

    public static void main(String[] args) throws InterruptedException {
        //启动线程
        TestJoin testJoin = new TestJoin();
        Thread thread = new Thread(testJoin);
        thread.start();

        for (int i = 0; i < 200; i++) {
            System.out.println("线程"+i);
            //在主线程i==100之前 主线程和thread线程交互执行
            //当主线程的i==100时，对thread线程启用join方法，主线程进入阻塞状态，等待thread执行完毕才继续执行
            if (i == 100){
                thread.join();
            }
        }
    }
}

4.5 用于线程通信的部分方法

  • wait()方法 让线程一直等待，直到其他线程通知，与sleep不同，wait等待时会释放锁。
  • wait(long timeout) 指定等待的毫秒数。
  • notify()方法 唤醒一个处于等待状态的线程。
  • notifyAll() 唤醒同一个对象上所有调用wait方法的线程，优先级别高的线程优先调度。

5. 线程优先级

  • Java提供一个线程调度器来监控程序中启动后进入就绪状态的所有线程，线程调度器按照优先级决定应该调度哪个线程来执行。
  • 线程的优先级用数字表示，范围从1~10。
    • Thread.MIN_PRIORITY = 1
    • Thread.MAX_PRIORITY = 10
    • Thread.NORM_PRIORITY = 5
  • 使用以下方式获取或改变优先级
    • getPriority()
    • setPriority(int xxx)
  • 线程的权重越大，被CPU优先执行的概率就越大。优先级低只是意味着获得调度的概率低，并不是优先级低就不会被调用了，这都是看CPU的调度。

PS：由于现在计算机的CPU都是多核多线程，不再是单核CPU同一时间只能执行一个线程，线程没有被完全占满，所以并不能在代码中直观的感受到优先级的不同

package com.chen.state;

//测试线程优先级
public class TestPriority {
    public static void main(String[] args) throws InterruptedException {
        //输出主线程的优先级
        System.out.println(Thread.currentThread().getName()+"-->"+Thread.currentThread().getPriority());
        
        MyPriority myPriority = new MyPriority();
        Thread t1 = new Thread(myPriority);
        Thread t2 = new Thread(myPriority);
        Thread t3 = new Thread(myPriority);
        Thread t4 = new Thread(myPriority);

        //设置优先级
        //优先级越大 先执行的概率就越大
        //PS：但是由于现在计算机的CPU都是多核多线程，不再是单核CPU同一时间只能执行一个线程，线程没有被完全占满，所以并不能直观的感受到优先级的不同
        t1.setPriority(8);
        t2.setPriority(4);
        t3.setPriority(Thread.MIN_PRIORITY);//设置最小优先级 MIN_PRIORITY=1
        t4.setPriority(Thread.MAX_PRIORITY);//设置最大优先级 MAX_PRIORITY=10
        
        //启动线程
        t1.start();
        t2.start();
        t3.start();
        t4.start();
    }

}

class MyPriority implements Runnable{
    @Override
    public void run() {
        //输出优先级
        System.out.println(Thread.currentThread().getName()+"-->"+Thread.currentThread().getPriority());
    }
}

6. 守护线程_Daemon

  • 线程分为用户线程和守护线程。
  • 虚拟机必须确保用户线程执行完毕。
  • 但虚拟机不用等待守护线程执行完毕。
  • 守护线程，例如：后台记录操作日志,监控内存,垃圾回收等待。
//将线程设置成守护线程   
thread.setDaemon(true); //默认是false 表示用户线程，正常的线程都是用户线程。当设置成true 表示守护线程

//虚拟机只需要确保用户线程执行完毕，不必等待守护线程执行完

7. 线程同步

  • 线程同步用于多个线程操作同一资源的情况，目的是为了防止并发问题的发生，提高安全性。
  • 线程同步其实就是一种等待机制，让一个线程访问共享数据的时候，锁住共享资源，其他线程只能等待该线程使用完毕后，才能继续操作共享资源。

同步方法：

  • 同步代码块
  • 同步方法
  • Lock锁

7.1 同步代码块

  • 同步代码块使用了一个锁，这个锁叫同步锁，也叫对象监视器。

  • 当线程遇到synchronized代码块，就会获取锁，执行代码块中的代码；这时其他线程进入synchronized代码块时，获取不到锁，就会进入阻塞状态，直到上一个线程执行完代码块归还锁，才能继续执行。

  • 同步代码块中的锁，可以是任意的对象或类，但是必须保证多个线程使用的锁是同一把锁，即同一个对象或类，否则无效。推荐使用共享资源所在的对象或类作为锁。

  • 通过实现Runnable接口创建多线程时，使用的是同一个对象；而用继承Thread类创建多线程时，会有多个对象，所以要锁住一样的对象资源

  • 使用同步代码块，可以提升程序的安全性，但也会造成程序会频繁的获取和释放锁，降低程序的效率。

synchronized(锁){
    可能会出现线程安全问题的代码(访问了共享数据的代码)
}

对买票案例使用同步代码块进行优化，使其安全

package com.chen.synchronize;

//买票案例
public class UnsafeBuyTickets {
    public static void main(String[] args) {
        BuyTickets buyTickets = new BuyTickets();

        new Thread(buyTickets,"小明").start();
        new Thread(buyTickets,"小红").start();
        new Thread(buyTickets,"黄牛").start();
    }
}

class BuyTickets implements Runnable{
    private int tickets = 100; //票数
    private boolean flag = true; //停止标志
    @Override
    public void run() {
        while (flag){
            buy();
        }
    }

    //买票
    private void buy(){
        try {
            //模拟延时
            Thread.sleep(10);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        //同步代码块 共享资源在本类中 传入this对象
        synchronized (this){
            //将操作共享资源tickets的代码都放入同步代码块中，使其安全
            if (tickets > 0){
                System.out.println(Thread.currentThread().getName()+"拿到了第"+tickets--+"张票");
            }else{
                flag = false;
            }
        }
    }
}

7.2 同步方法

  • 使用Synchronized修饰的方法被称为同步方法。
  • 当Synchronized修饰非静态方法时，锁定的是对象，即类的实例；修饰静态方法时，锁定的是类。
  • 同步方法被多个线程调用时，必须保证多个线程使用的是同一对象调用，否则无效。
  • 通过实现Runnable接口创建多线程时，使用的是同一个对象；而用继承Thread类创建多线程时，会有多个对象，所以要锁住一样的对象资源
//1.将访问共享数据的代码抽取出来放入一个方法中
//2.在方法上添加synchronized修饰符，使其成为同步方法
public synchronized void method(){
    可能会产生线程安全问题的代码
}

使用同步方法优化买票案例，使其安全

package com.chen.synchronize;

//买票案例
public class UnsafeBuyTickets {
    public static void main(String[] args) {
        BuyTickets buyTickets = new BuyTickets();

        new Thread(buyTickets,"小明").start();
        new Thread(buyTickets,"小红").start();
        new Thread(buyTickets,"黄牛").start();
    }
}

class BuyTickets implements Runnable{
    private int tickets = 100; //票数
    private boolean flag = true; //停止标志
    @Override
    public void run() {
        while (flag){
            try {
                //模拟延时
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            buy();
        }
    }
    //将操作共享资源tickets的代码抽取到buy()方法中
    //并加上synchronized修饰符使其成为同步方法
    private synchronized void buy(){
        if (tickets > 0){
            System.out.println(Thread.currentThread().getName()+"拿到了第"+tickets--+"张票");
        }else{
            flag = false;
        }
    }
}

7.3 死锁问题

死锁是指多个线程互相拿着对方需要的资源，形成僵持。

产生死锁的四个必要条件

  • 互斥条件：一个资源每次只能被一个进程使用。
  • 请求与保持条件：一个进程因请求资源而阻塞时，对已获得的资源保持不放。
  • 不剥夺条件：进程已获得的资源，在末使用完之前，不能强行剥夺。
  • 循环等待条件：若干进程之间形成一种头尾相接的循环等待资源关系。

只要破除任意一个或多个条件就可避免死锁发生。

死锁案例：两个线程互相拿到对方所需资源，谁也不释放，就形成了死锁

package com.chen.lock;

//死锁：多个线程互相拿着对方需要的资源，形成僵持
public class DeadLock {
    public static void main(String[] args) {
        Makeup girl1 = new Makeup(0,"灰姑娘");
        Makeup girl2 = new Makeup(1,"白雪公主");
        //两个线程互相拿到对方所需资源，谁也不释放，就形成了死锁
        girl1.start();
        girl2.start();
    }
}
//口红
class Lipstick{}

//镜子
class Mirror{}

//化妆类
class Makeup extends Thread{
    static Lipstick lipstick = new Lipstick();//口红
    static Mirror mirror = new Mirror();//镜子

    int choice;//选择
    String name;
    @Override
    public void run() {
        makeup();
    }

    //构造器传参
    public Makeup(int choice,String name) {
        this.choice = choice;
        this.name = name;
    }

    //化妆
    public void makeup(){
        if (choice==0){
            //选择为0时，先去拿口红，拿到口红后不释放口红，继续去拿镜子
            synchronized (lipstick){
                System.out.println("拿到口红");
                synchronized (mirror){
                    System.out.println("拿到镜子");
                }
            }
        }else{
            //选择不为0时，先去拿镜子，拿到镜子后不释放镜子，继续去拿口红
            synchronized (mirror){
                System.out.println("拿到镜子");
                synchronized (lipstick){
                    System.out.println("拿到口红");
                }
            }
        }
    }
}

运行结果：两个线程都无法拿到所需资源，形成僵持，程序无法结束

在这里插入图片描述

修改方法：只需让两个线程拿对方资源前将自己手上的资源释放即可，即将第二个同步代码块拿出来，不要嵌套在第一个同步代码块中；

//化妆
    public void makeup(){
        if (choice==0){
            //选择为0时，先去拿口红，拿到口红后不释放口红，继续去拿镜子
            synchronized (lipstick){
                System.out.println("拿到口红");
            }
            synchronized (mirror){
                System.out.println("拿到镜子");
            }
        }else{
            //选择不为0时，先去拿镜子，拿到镜子后不释放镜子，继续去拿口红
            synchronized (mirror){
                System.out.println("拿到镜子");
            }
            synchronized (lipstick){
                System.out.println("拿到口红");
            }
        }
    }

修改后运行结果：

在这里插入图片描述

7.4 Lock锁

Lock锁是显示定义的锁

定义一个ReentrantLock类型的锁，然后通过 .lock() 加锁 和 .unlock() 解锁 来锁住不安全的代码区域。

通过Lock锁使买票案例安全

package com.chen.lock;

import java.util.concurrent.locks.ReentrantLock;

public class TestLock {
    public static void main(String[] args) {
        BuyTickets buyTickets = new BuyTickets();
        new Thread(buyTickets).start();
        new Thread(buyTickets).start();
        new Thread(buyTickets).start();
    }
}

class BuyTickets implements Runnable{
    int tickets = 100;

    ReentrantLock lock = new ReentrantLock(); //定义lock锁
    @Override
    public void run() {
        while (true){
            try {
                
                //加锁
                lock.lock();
                
                if (tickets>0){
                    try {
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName()+"拿到了第"+tickets--+"张票");
                }else {
                    break;
                }
            }finally {

                //解锁
                lock.unlock();
            }
        }
    }
}

7.5 Synchronized和Lock的对比

  • Lock是显式锁（手动开启和关闭锁，别忘记关闭锁）， synchronized是隐式锁，出了作用域自动释放。
  • Lock只有代码块锁，synchronized有代码块锁和方法锁。
  • 使用Lock锁，JVM将花费较少的时间来调度线程，性能更好，并且具有更好的扩展性(提供更多的子类)。
  • 优先使用顺序:
    Lock > 同步代码块(已经进入了方法体，分配了相应资源) > 同步方法(在方法体之外)。
雨落青城夜微凉
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
java多线程基础学习文档
10-27
以上就是Java多线程基础学习的一些关键知识点，理解并掌握这些内容对于进行高效的多线程编程至关重要。在实际开发中，还需要根据具体需求选择合适的线程模型和同步机制，以实现高效、安全的并发程序。
JAVA-多线程 所有文件
01-09
这个“JAVA-多线程 所有文件”压缩包很可能包含了一系列关于Java多线程学习的源代码示例和相关文档。下面我们将深入探讨Java多线程的相关知识点。 1. **线程的概念**：线程是操作系统分配CPU时间的基本单位，一个...
JAVA多线程与并发学习总结分析
09-05
总的来说，JAVA多线程与并发的学习涵盖了从硬件层面的缓存一致性到软件层面的内存模型、原子性、可见性和有序性，以及解决并发问题的关键机制如volatile和synchronized。理解并掌握这些知识点对于编写高效、安全的...
Java-学习多线程总结上
12-22
每一个正在执行的程序都是一个进程，资源只有一块，所以在同一时间段会有多个程序同时执行，但是在一个时间点上，只能由一个程序执行，多线程是在一个进程的基础之上的进一步划分，因为进程的启动所消耗的时间是非常...
基础语法_java多线程_
10-03
Java多线程是Java编程中的重要概念，它允许程序...Java多线程的学习涵盖了并发编程的基础和高级概念，是成为专业Java开发者必备的技能之一。通过不断实践和理解，能够有效地处理复杂并发场景，提升程序的性能和稳定性。
z3基础学习
google20的博客
08-02 99
略
安全基础学习-keil调试汇编代码
小夭的博客
07-31 581
初始目的是为了通过汇编编写CRC功能。但是基础为0，所以目前从搭建工程开始记录。大佬绕路。
机械学习—零基础学习日志（高数18——无穷小与无穷大）
AI_freshfish的博客
08-01 342
这里可以记住，无穷小有一个特殊，那就是零。零是最高阶的无穷小，且零是唯一一个常数无穷小。张宇老师还是使用了超实数概念来讲解无穷小。其实是利于理解的，但希望大家接触新概念过程不要太抗拒。数学概念理解，其实可以借用生活概念。张宇老师这里把1除以无穷小，理解成把1分为若干个无穷小。所以得到的就是无穷大。1除以超实数所以得到超实数的结果。
从零开始学习网络安全渗透测试之基础入门篇——（六）网络抓包&全局协议&封包监听&网卡模式&科来&wireshark&PC应用
love6a6的博客
08-02 575
是一种用于捕获和分析网络数据包的技术手段。它能够帮助我们深入了解网络中的数据传输情况，对于网络故障排查、性能优化、安全监测等方面都具有重要意义。网络抓包的工作原理通常是通过将网络接口设置为混杂模式，使其能够接收流经该接口的所有数据包。然后，使用专门的抓包软件或工具对这些数据包进行捕获和存储。为了方便大家使用，作者收集到百度网盘分享学习。链接：https://pan.baidu.com/s/1uKUsQfIlWOxTNPvU8DewKQ?pwd=mf7v提取码：mf7v。
【C++】构造函数的深入学习
weixin_60546365的博客
07-30 383
所有对象共享同一份数据 -- 你改了别人用的就是改过的数据。类中声明，类外初始化 -- 必须要有一个初始值否则没法用。所有对象共享同一个函数，类外访问不到私有静态函数。静态成员函数只能访问静态成员变量。静态成员变量访问权限：在Private作用域下访问，出了这个类不可以访问。分配内存 -- 生成了exe程序，还没有双击运行之前已经分配在全局区中。语法：构造函数（）：属性1（值1），属性2（值2）...{ }先构造A再构造B，先析构B再析构A（先进后出LIFO）C++提供初始化列表语法用来初始化属性。
编程的魅力、发展历程、核心要素、学习路径以及它对个人成长和社会进步的深远影响
z86666610的博客
08-02 178
进入21世纪，随着互联网的普及和移动设备的兴起，编程语言更加多样化，如Python、JavaScript等，它们以其简洁易学的特点吸引了大量初学者。同时，人工智能、大数据、云计算等新兴技术的快速发展，更是将编程推向了新的高度，使得编程成为推动社会进步的重要力量。编程的魅力，在于它让我们能够将自己的想法直接转化为现实，体验到从无到有的创造过程。本文将深入探讨编程的魅力、发展历程、核心要素、学习路径以及它对个人成长和社会进步的深远影响，旨在为读者勾勒出一幅全面而生动的编程世界图景。
C语言零基础学习笔记11——分支和循环（五）
Lbs_gemini0603的博客
08-02 935
C语言零基础学习笔记11——分支和循环（五）
总线学习3--SPI（TODO）
fanged的专栏
08-02 94
【代码】总线学习3--SPI（TODO）
学习大数据DAY30 python基础语法3
shh2000424的博客
08-02 562
上机练习5的作业我昨天就写完了，但是因为它是今天的作业，我就今天发咯。按行作为分隔符条件，返回所有行组成的列表（每行内容是一个元素）今天写的代码比较多，但是整理一下思路还是不难写的。检测到一个错误时，解释器就无法继续执行（程序。了，反而出现了一些错误提示，这就是所谓的异常。方法将任何字符串写入打开的文件，换行符。方法则是读取所有行，一次性全部读出，取款机程序重新执行数据没有保存。文件以字典的形式存储在列表里。语句抛出一个指定的异常。
学习笔记——交通安全分析17
你好！
08-02 244
#随着上一轮SPSS学习完成之后，本人又开始了新教材《交通安全分析》的学习 #整理过程不易，喜欢UP就点个免费的关注趴 #本期内容接上一期16笔记
【OpenCV C++20 学习笔记】腐蚀和膨胀
TeamLee的博客
07-31 468
简单介绍OpenCV中的膨胀和腐蚀的原理及操作
MyBatis 源码学习 | Day 1 | 了解 MyBatis
weixin_59271089的博客
08-02 553
MyBatis 是一个 Java持久层框架，用于简化数据库的操作。它通过 XML 或注解的方式配置和映射原始类型、接口和Java POJO（Plain Old Java Objects，普通老式 Java 对象）为数据库中的记录
操作系统篇--八股文学习第十二天| 什么是死锁，如何避免死锁？，介绍一下几种典型的锁，讲一讲你理解的虚拟内存
m0_67804957的博客
08-02 237
什么是死锁，如何避免死锁？，介绍一下几种典型的锁，讲一讲你理解的虚拟内存
C高级（学习）2024.8.2
最新发布
qq_60450758的博客
08-02 693
C高级，指针函数，函数指针，函数指针数组，共用体，枚举，存贮类型，条件编译
Java多线程基础与实战
本文旨在介绍Java多线程的基础知识，包括线程的实现方式、线程同步以及线程状态等核心概念。" 在Java中，线程是一个程序执行的最小单元，它代表了进程中的单一控制流。与进程相比，线程更加轻量级，因为它们共享...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值