多线程相关知识

于 2021-07-16 16:49:17 发布
阅读量69 收藏
点赞数
分类专栏： 多线程 文章标签： 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_51458935/article/details/118807080
版权

多线程

多任务

在这里插入图片描述

普通方法调用和多线程

在这里插入图片描述

普通方法(调用run()方法)效率低

//创建线程方式一：继承Thread类，重写run()方法，调用start开启线程

//总结：注意，线程开启不一定立即执行，由cpu调度执行

public class TestThread1 extends Thread{
    @Override
    public void run() {
        //run方法线程体
        for (int i = 0; i < 10; i++) {
            System.out.println("我在看电视--"+i);
        }
    }

    public static void main(String[] args) {
        //main线程，主线程

        //创建一个线程对象
        TestThread1 testThread1 = new TestThread1();

        //调用run()方法开启线程
        testThread1.run();

        for (int i = 0; i < 10; i++) {
            System.out.println("我在执行main--"+i);
        }
    }
}

结果，如下图

在这里插入图片描述

多线程(调用start()方法)效率高

//创建线程方式一：继承Thread类，重写run()方法，调用start开启线程

//总结：注意，线程开启不一定立即执行，由cpu调度执行

public class TestThread1 extends Thread{
    @Override
    public void run() {
        //run方法线程体
        for (int i = 0; i < 10; i++) {
            System.out.println("我在看电视--"+i);
        }
    }

    public static void main(String[] args) {
        //main线程，主线程

        //创建一个线程对象
        TestThread1 testThread1 = new TestThread1();

        //调用start()方法开启线程
        testThread1.start();

        for (int i = 0; i < 10; i++) {
            System.out.println("我在执行main--"+i);
        }
    }
}

结果，如下图

在这里插入图片描述

进程与线程

在这里插入图片描述

核心概念

在这里插入图片描述

线程的创建

在这里插入图片描述

Thread

在这里插入图片描述

//创建线程方式一：继承Thread类，重写run()方法，调用start开启线程

//总结：注意，线程开启不一定立即执行，由cpu调度执行

public class TestThread1 extends Thread{
    @Override
    public void run() {
        //run方法线程体
        for (int i = 0; i < 10; i++) {
            System.out.println("我在看电视--"+i);
        }
    }

    public static void main(String[] args) {
        //main线程，主线程

        //创建一个线程对象
        TestThread1 testThread1 = new TestThread1();

        //调用start()方法开启线程
        testThread1.start();

        for (int i = 0; i < 10; i++) {
            System.out.println("我在执行main--"+i);
        }
    }
}

Runnable

在这里插入图片描述

//创建线程方式2：实现runnable接口，重写run方法，执行线程需要丢入runnable接口实现类，调用start方法
public class TestThread1 implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println("我在执行run--"+i);
        }
    }

    public static void main(String[] args) {
        //创建runnable接口的实现类对象
        TestThread1 testThread1 = new TestThread1();

        //创建线程对象，通过线程对象来开启我们的线程，代理
        Thread thread = new Thread(testThread1);
        thread.start();

        for (int i = 0; i < 10; i++) {
            System.out.println("我在执行main--"+i);
        }
    }
}

对比Thread和Runnable

在这里插入图片描述

初始并发问题（火车票）

//多个线程同时操作同一个对象
//买火车票的例子

//发现问题：多个线程操作同一个资源的情况下，线程不安全
public class TestThread1 implements Runnable{

    //票数
    private int ticketNums = 10;
    @Override
    public void run() {

        while (true){
            if (ticketNums<=0){
                break;
            }
            System.out.println(Thread.currentThread().getName()+"拿到了第"+ticketNums--+"票");
        }

    }

    public static void main(String[] args) {
        TestThread1 testThread1 = new TestThread1();

        new Thread(testThread1,"小明").start();
        new Thread(testThread1,"小红").start();
        new Thread(testThread1,"小乐").start();
    }


}

结果，如下图

在这里插入图片描述

龟兔赛跑

在这里插入图片描述

package com.qw;

//模拟龟兔赛跑
public class TestThread1 implements Runnable{

    //胜利者
    private static String winner;

    @Override
    public void run() {
        for (int i = 0; i <= 100; i++) {

            //模拟兔子休息
            if (Thread.currentThread().getName().equals("兔子")&& i%10==0){
                try {
                    Thread.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }

            //判断比赛是否结束
            boolean flag = gameOver(i);
            //如果比赛结束了，就停止程序
            if (flag){
                break;
            }
            System.out.println(Thread.currentThread().getName()+"-->跑了"+i+"步");
        }

    }

    //判断是否完成比赛
    private boolean gameOver(int steps){
        //判断是否有胜利者
        if (winner!=null){
            return true;
        }else {
            if (steps>=100){
                winner = Thread.currentThread().getName();
                System.out.println("winner is"+winner);
                return true;
            }
        }
        return false;
    }

    public static void main(String[] args) {
        TestThread1 testThread1 = new TestThread1();

        new Thread(testThread1,"兔子").start();
        new Thread(testThread1,"乌龟").start();


    }


}

结果，如下图

在这里插入图片描述

静态代理

在这里插入图片描述

//静态代理模式总结：
//真实对象和代理对象都要实现同一个接口
//代理对象要代理真实角色

//好处：
    //代理对象可以做很多真实对象做不了的事情
    //真实对象专注做自己的事情
public class TestThread1 {
    public static void main(String[] args) {

        You you = new You();
        
        new Thread( ()-> System.out.println("我爱你")).start();
        
        new WeddingCompany(you).HappyMarry();
    }
}

interface Marry{
    void HappyMarry();
}

//结婚角色，You去结婚
class You implements Marry{
    @Override
    public void HappyMarry() {
        System.out.println("结婚了，开心");
    }
}

//代理角色，帮助You去结婚
class WeddingCompany implements Marry{

    //代理真实目标角色
    private Marry target;

    public WeddingCompany(Marry target) {
        this.target = target;
    }

    @Override
    public void HappyMarry() {
        before();
        this.target.HappyMarry();//这就是真实对象
        after();
    }

    private void after() {
        System.out.println("结婚之后，收尾款");
    }

    private void before() {
        System.out.println("结婚之前，布置现场");
    }
}

Lamda表达式

  • 在这里插入图片描述

  • 在这里插入图片描述

package com.qw;

/*
推导lambda表达式
 */
public class TestThread1 {

    //3.静态内部类
    static class Like2 implements ILike{
        @Override
        public void lambda(int a) {
            System.out.println("I like lambda"+a);
        }
    }

    public static void main(String[] args) {
        //实现类
        ILike like = new Like();
        like.lambda(0);

        //静态内部类
        like = new Like2();
        like.lambda(1);

        //4.局部内部类
        class Like3 implements ILike{
            @Override
            public void lambda(int a) {
                System.out.println("I like lambda"+a);
            }
        }

        like = new Like3();
        like.lambda(2);

        //5.匿名内部类 没有类的名称，必须借助接口或者父类
        like = new ILike() {
            @Override
            public void lambda(int a) {
                System.out.println("I like lambda"+a);
            }
        };
        like.lambda(3);

        //6.用lamdba简化
        like = (int a)->{
            System.out.println("I like lambda"+a);
        };
        like.lambda(4);

        //7.用lamdba简化括号,参数只能有一个才能去掉括号，否则加上括号 例如：like = (a,b)->
        like = a->{
            System.out.println("I like lambda"+a);
        };
        like.lambda(5);

        //8.用lamdba简化花括号，只有一行代码才能去掉花括号简化为一行
        like = a-> System.out.println("I like lambda"+a);
        like.lambda(6);


    }

}

//1.定义一个函数式接口（只有一个方法）
interface ILike{
    void lambda(int a);
}

//2.实现类
class Like implements ILike{
    @Override
    public void lambda(int a) {
        System.out.println("I like lambda"+a);
    }
}

结果，如下图

在这里插入图片描述

停止线程

在这里插入图片描述

package com.qw;

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

    //1.设置一个标识位
    private boolean flag = true;
    @Override
    public void run() {
        int i = 0;
        while (flag){
            System.out.println("run..Thread"+i++);
        }

    }

    public void stop(){
        this.flag = false;
    }

    public static void main(String[] args) {
        Test test = new Test();

        new Thread(test).start();

        for (int i = 0; i < 1000; i++) {
            System.out.println("main"+i);
            if(i==900){
                test.stop();
                System.out.println("线程该停止了");
            }
        }
    }

}

结果，如下图

在这里插入图片描述

线程休眠

在这里插入图片描述

//秒钟倒计时
public class Test {

    public static void tenDown() throws InterruptedException {
        int num = 10;
        while (true){
            Thread.sleep(1000);
            System.out.println(num);
            num--;
            if (num==0){
                break;
            }
        }
    }

    public static void main(String[] args) {
        try {
            tenDown();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

}

//打印系统时间
    public static void main(String[] args) throws InterruptedException {
        Date startTime = new Date(System.currentTimeMillis());

        while (true) {
            try {
                Thread.sleep(1000);
                System.out.println(new SimpleDateFormat("HH:mm:ss").format(startTime));
                startTime = new Date(System.currentTimeMillis());
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

        }
    }

线程礼让

在这里插入图片描述

//测试礼让线程
//礼让不一定成功，看cpu的调用
public class Test {

    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()+"线程停止执行");
    }
}

礼让成功，如下图

在这里插入图片描述

礼让不成功，如下图

在这里插入图片描述

Join

在这里插入图片描述

线程状态观测

在这里插入图片描述

//观察测试线程状态
public class Test {

    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(()->{
            for (int i = 0; i < 5; i++) {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println("//");
        });

        //观察状态
        Thread.State state = thread.getState();
        System.out.println(state);//NEW

        //观察启动后
        thread.start();//启动线程
        state = thread.getState();
        System.out.println(state);//Run

        while (state != Thread.State.TERMINATED){//只要线程不终止，就一直输出状态
            Thread.sleep(100);
            state = thread.getState();
            System.out.println(state);
        }
    }
}

结果，如下图

在这里插入图片描述

线程优先级

在这里插入图片描述

//线程的优先级
public class Test {

    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);
        Thread t5 = new Thread(myPriority);
        Thread t6 = new Thread(myPriority);

        //先设置优先级，在启动
        t1.setPriority(1);
        t1.start();

        t2.setPriority(5);
        t2.start();

        t3.setPriority(2);
        t3.start();

        t4.setPriority(Thread.MAX_PRIORITY);
        t4.start();
    }
}
class MyPriority implements Runnable{
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"-->"+Thread.currentThread().getPriority());
    }
}

结果，如下图

在这里插入图片描述

不一定优先级越高就先执行，只是先执行概率更大

守护线程

在这里插入图片描述

package com.qw;

//测试守护线程
public class Test {

    public static void main(String[] args) {
        God god = new God();
        You you = new You();

        Thread thread = new Thread(god);
        thread.setDaemon(true);//默认是false表示是用户线程，正常的线程都是用户线程
        thread.start();//线程启动

        new Thread(you).start();//You 启动线程

    }
}
//上帝
class God implements Runnable{
    @Override
    public void run() {
        while (true){
            System.out.println("上帝守护你");
        }
    }
}
//你
class You implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 33356; i++) {
            System.out.println("活着好开心");
        }
        System.out.println("goodbye，world");

    }
}

等到用户线程停止了，守护线程会自动停止

线程同步

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

三大不安全案例

1.不安全的买票

//不安全的买票
public class Test {
    public static void main(String[] args) {
        BuyTicket buyTicket = new BuyTicket();

        new Thread(buyTicket).start();
        new Thread(buyTicket,"李四").start();
        new Thread(buyTicket,"王五").start();
    }

}

class BuyTicket implements Runnable{

    private int ticketNum = 10;
    boolean flag = true;

    @Override
    public void run() {
        while (flag){
            try {
                buy();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    public void buy() throws InterruptedException {
        //判断是否有票
        if (ticketNum<=0){
            flag = false;
            return;
        }
        Thread.sleep(1000);

        System.out.println(Thread.currentThread().getName()+"拿到"+ticketNum--);
    }
}

结果，如下图

在这里插入图片描述

2.不安全的取钱

package com.qw;

//不安全的取钱
//两个人去银行取钱，账户
public class Test {
    public static void main(String[] args) {
        //账户
        Account account = new Account(100,"基金");

        Drawing you = new Drawing(account,50,"你");

        Drawing he = new Drawing(account,100,"he");

        you.start();
        he.start();

    }
}

//账户
class Account{
    String name;//卡名
    int money;//余额
    public Account(int money,String name){
        this.money = money;
        this.name = name;
    }
}

//银行：模拟取款
class Drawing extends Thread{
    Account account;//账户

    int drawingMoney;//取了多少钱

    int nowMoney;//现在手里有多少钱

    public Drawing(Account account,int drawingMoney,String name){
        super(name);
        this.account = account;
        this.drawingMoney = drawingMoney;
    }

    //取钱
    @Override
    public void run() {
        //判断有没有钱
        if (account.money-drawingMoney<0){
            System.out.println(Thread.currentThread().getName()+"钱不够了");
            return;
        }

        //sleep可以放大问题的发生性
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        
        //卡内余额 = 余额 - 取的钱
        account.money = account.money-drawingMoney;

        //手里的钱
        nowMoney = nowMoney + drawingMoney;

        System.out.println(account.name+"余额为："+account.money);
        System.out.println(this.getName()+"手里的钱为："+nowMoney);


    }
}

结果，如下图

在这里插入图片描述

3.线程不安全的集合

import java.util.ArrayList;
import java.util.List;

public class Test {
    public static void main(String[] args) throws InterruptedException {
        List<String> list = new ArrayList<String>();
        for (int i = 0; i < 10000; i++) {
            new Thread(()->{
                list.add(Thread.currentThread().getName());
            }).start();
        }
        
        System.out.println(list.size());

    }
}

结果，如下图

在这里插入图片描述

同步方法

在这里插入图片描述

1.安全的买票

package com.qw;

//不安全的买票
public class Test {
    public static void main(String[] args) {
        BuyTicket buyTicket = new BuyTicket();

        new Thread(buyTicket,"张三").start();
        new Thread(buyTicket,"李四").start();
        new Thread(buyTicket,"王五").start();
    }

}

class BuyTicket implements Runnable{

    private int ticketNum = 10;
    boolean flag = true;

    @Override
    public void run() {
        while (flag){
            try {
                buy();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    //synchronized 同步方法，锁的是this
    public synchronized void buy() throws InterruptedException {
        //判断是否有票
        if (ticketNum<=0){
            flag = false;
            return;
        }
        //模拟延时
        Thread.sleep(100);
        //买票
        System.out.println(Thread.currentThread().getName()+"拿到"+ticketNum--);
    }
}

结果，如下图

在这里插入图片描述

2.安全的取钱

package com.qw;


//不安全的取钱
//两个人去银行取钱，账户
public class Test {
    public static void main(String[] args) {
        //账户
        Account account = new Account(1000,"基金");

        Drawing you = new Drawing(account,50,"你");

        Drawing he = new Drawing(account,100,"he");

        you.start();
        he.start();

    }
}

//账户
class Account{
    String name;//卡名
    int money;//余额
    public Account(int money,String name){
        this.money = money;
        this.name = name;
    }
}

//银行：模拟取款
class Drawing extends Thread{
    Account account;//账户

    int drawingMoney;//取了多少钱

    int nowMoney;//现在手里有多少钱

    public Drawing(Account account,int drawingMoney,String name){
        super(name);
        this.account = account;
        this.drawingMoney = drawingMoney;
    }

    //取钱
    //synchronized 默认锁的是this
    @Override
    public void run() {

        //锁的对象就是变化的量，需要增删改的对象
        synchronized (account){
            //判断有没有钱
            if (account.money-drawingMoney<0){
                System.out.println(Thread.currentThread().getName()+"钱不够了");
                return;
            }

            //sleep可以放大问题的发生性
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            //卡内余额 = 余额 - 取的钱
            account.money = account.money-drawingMoney;

            //手里的钱
            nowMoney = nowMoney + drawingMoney;

            System.out.println(account.name+"余额为："+account.money);
            System.out.println(this.getName()+"手里的钱为："+nowMoney);

        }


    }
}

结果，如下图

在这里插入图片描述

3.线程安全的集合

import java.util.ArrayList;
import java.util.List;

public class Test {
    public static void main(String[] args) throws InterruptedException {
        List<String> list = new ArrayList<String>();
        for (int i = 0; i < 10000; i++) {
            new Thread(()->{
                synchronized (list){
                    list.add(Thread.currentThread().getName());
                }
            }).start();
        }
        Thread.sleep(2000);

        System.out.println(list.size());

    }
}

结果，如下图

在这里插入图片描述

死锁

在这里插入图片描述

//死锁：多个线程互相抱着对方需要的资源，然后形成僵持
//此程序避免了死锁
public class Test {
    public static void main(String[] args) throws InterruptedException {
        Makeup g1 = new Makeup(0,"灰姑娘");
        Makeup g2 = new Makeup(1,"白雪公主");

        g1.start();
        g2.start();


    }
}
//口红
class Lipstick{

}

//镜子
class Mirror{

}

class Makeup extends Thread{
    //需要的资源只有一份，用static来保证只有一份
    static Lipstick lipstick = new Lipstick();
    static Mirror mirror = new Mirror();

    int choice;//选择
    String girlName;//使用化妆品的人

    Makeup(int choice,String girlName){
        this.choice = choice;
        this.girlName = girlName;
    }

    @Override
    public void run() {
        try {
            makeup();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    //化妆，互相持有对方的锁，就是需要拿到对方的资源
    private void makeup() throws InterruptedException {
        if (choice==0){
            synchronized (lipstick){
                System.out.println(this.girlName+"获得口红的锁");
                Thread.sleep(1000);
            }
            synchronized (mirror){
                System.out.println(this.girlName+"获得镜子的锁");
            }
        }else {
            synchronized (mirror){
                System.out.println(this.girlName+"获得镜子的锁");
                Thread.sleep(1000);
            }
            synchronized (lipstick){
                System.out.println(this.girlName+"获得口红的锁");
            }
        }
    }
}

结果，如下图

在这里插入图片描述

J练习生
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java多线程相关知识总结
03-15
Java多线程相关知识总结
多线程相关知识源码-----多线程案例源码
07-15
多线程相关知识源码-----多线程案例源码
多线程面试相关知识点
06-01
多线程 1. 什么是线程： 线程就是程序中单独顺序的流控制。线程本身不能运行，它只能用于程序中。 2. 什么是多线程： 多线程则指的是在单个程序中可以同时运行多个不同的线程执行不同的任务. 说明： 线程是程序内...
Java多线程知识点总结
08-19
该文档总结了Java多线程相关的知识点，分享给大家，简单易懂！
多线程知识梳理.xmind
01-09
从多线程的基础、线程同步、线程间通信、线程调度、线程池、并发容器、线程安全的集合、原子变量等方面去罗列主要知识点，以思维导图的方式进行呈现，可以让读者更条理清晰的在最短的时间内掌握多线程的主要知识
咖啡店管理系统 (Java 版) 源代码+使用说明+可做毕设
06-17
咖啡店管理系统 (Java 版) 源代码 项目简介 这个 Java 项目是一个简单的商店管理系统。该系统处理任何咖啡酒店的业务细节。要制作这个项目，你需要 JetBrains IntelliJ IDE。这个 IDE 将为项目提供设置。你还需要 PostgreSQL 作为数据库。设计简单且用户友好。 系统介绍 关于 Java 版咖啡店管理系统，该系统处理酒店用户的管理。在使用系统之前，你需要先注册然后登录系统。从那里你可以管理你的工作空间，你可以添加客户，管理销售并进行更新。 设计非常简单，用户在操作时不会遇到困难。该项目易于操作和理解。要运行此项目，你必须在电脑上安装 Eclipse IDE 或 JetBrains IntelliJ IDE。 该项目为国外大神项目，可以作为毕业设计的项目，也可以作为大作业项目，不用担心代码重复，设计重复等，如果需要对项目进行修改，需要具备一定基础知识。 注意：如果装有360等杀毒软件，可能会出现误报的情况，源码本身并无病毒，使用源码时可以关闭360，或者添加信任。
vspdconfig虚拟串口软件
06-17
用于添加虚拟串口，而不用连接硬件，方便调试。
仿真设计zzz.uvproj
最新发布
06-17
asdf.uvproj
强大且美观的WPF UI控件库：HandyControl
06-17
HandyControl是一套WPF控件库，它几乎重写了所有原生样式，同时包含80余款自定义控件。使用HandyControl你可以轻松地创建一个美观的WPF应用程序，从而大大提高开发效率。
高分项目，基于Unity3D开发实现的打砖块游戏，内含完整源码+资源
06-17
高分项目，基于Unity3D开发实现的打砖块游戏，内含完整源码+资源 一款经典的打砖块游戏，画面清晰玩法简单，运行流畅。游戏包括60个关卡，支持3种不同速度的节奏。《打砖块 高清版 Krakout HD》是一款经典的打砖块游戏，你可以自己玩也可以跟朋友一起玩双人模式，游戏有丰富的背景，大量的关卡，劲爆的音乐。PS:如果出现ERR:...
grpcio-1.7.0-cp36-cp36m-win32.whl
06-17
Python库是一组预先编写的代码模块，旨在帮助开发者实现特定的编程任务，无需从零开始编写代码。这些库可以包括各种功能，如数学运算、文件操作、数据分析和网络编程等。Python社区提供了大量的第三方库，如NumPy、Pandas和Requests，极大地丰富了Python的应用领域，从数据科学到Web开发。Python库的丰富性是Python成为最受欢迎的编程语言之一的关键原因之一。这些库不仅为初学者提供了快速入门的途径，而且为经验丰富的开发者提供了强大的工具，以高效率、高质量地完成复杂任务。例如，Matplotlib和Seaborn库在数据可视化领域内非常受欢迎，它们提供了广泛的工具和技术，可以创建高度定制化的图表和图形，帮助数据科学家和分析师在数据探索和结果展示中更有效地传达信息。
grpcio-1.7.3-cp36-cp36m-win32.whl
06-17
Python库是一组预先编写的代码模块，旨在帮助开发者实现特定的编程任务，无需从零开始编写代码。这些库可以包括各种功能，如数学运算、文件操作、数据分析和网络编程等。Python社区提供了大量的第三方库，如NumPy、Pandas和Requests，极大地丰富了Python的应用领域，从数据科学到Web开发。Python库的丰富性是Python成为最受欢迎的编程语言之一的关键原因之一。这些库不仅为初学者提供了快速入门的途径，而且为经验丰富的开发者提供了强大的工具，以高效率、高质量地完成复杂任务。例如，Matplotlib和Seaborn库在数据可视化领域内非常受欢迎，它们提供了广泛的工具和技术，可以创建高度定制化的图表和图形，帮助数据科学家和分析师在数据探索和结果展示中更有效地传达信息。
intel_openmp-2023.2.4-py2.py3-none-manylinux1_i686.whl
06-17
Python库是一组预先编写的代码模块，旨在帮助开发者实现特定的编程任务，无需从零开始编写代码。这些库可以包括各种功能，如数学运算、文件操作、数据分析和网络编程等。Python社区提供了大量的第三方库，如NumPy、Pandas和Requests，极大地丰富了Python的应用领域，从数据科学到Web开发。Python库的丰富性是Python成为最受欢迎的编程语言之一的关键原因之一。这些库不仅为初学者提供了快速入门的途径，而且为经验丰富的开发者提供了强大的工具，以高效率、高质量地完成复杂任务。例如，Matplotlib和Seaborn库在数据可视化领域内非常受欢迎，它们提供了广泛的工具和技术，可以创建高度定制化的图表和图形，帮助数据科学家和分析师在数据探索和结果展示中更有效地传达信息。
高分项目，基于Unity3D开发实现的精品即时战略游戏，内含完整源码+资源+unitypackage
06-17
高分项目，基于Unity3D开发实现的精品即时战略游戏，内含完整源码+资源+unitypackage 即时战略游戏的形态经过了漫长的演变,按照如今的标准,是很难确定其前身的。这个游戏类型在英国与北美走过了各自的发展道路,最终融合成一个共同的形态。 在英国,即时战略可以追溯至1983年,由John Gibson开发的《Stonkers》,以及1987年发行的《Nether Earth》。这两款游戏都发行在ZX Spectrum家用电脑上。
简历模板简洁风精致求职简历模板多年经验简洁线条.zip
06-17
在竞争激烈的职场中，一份专业且引人注目的简历是你通往梦想工作的黄金钥匙。我们特别为你呈现精选的面试求职简历模板，每一款都设计独特、格式清晰，帮助你在众多候选人中脱颖而出。 这些简历模板采用多种风格与布局，无论是创新、传统还是现代简约，都能满足不同行业与职位的需求。它们不只拥有吸引人的外表，更重要的是其实用性强，使得招聘经理能一眼捕捉到你的核心竞争力与职业亮点。 模板的易编辑性让你能快速个性化地调整内容，针对性地展现你的才华和经验。使用这些模板，你将更容易获得面试机会，并有效地向雇主展示你的潜力和价值。 不要让平凡无奇的简历阻挡你的职场前进之路。立即下载这些令人眼前一亮的简历模板，开启你的职场新旅程。记住，美好的第一印象是成功的开始，而一份精心制作的简历，就是你赢得梦想工作的第一块敲门砖。
视觉密度、信息密度、设计密度
06-17
1.等多个维度说明UI设计思路 2.理论与实践的有效结合
数学建模将现实世界的问题抽象化为数学模型利用数学工具和技术来分析和解决
06-17
数学建模是将现实世界的问题抽象化为数学模型，并利用数学工具和技术来分析和解决这些问题的过程。它在科学、工程、经济、环境等各个领域中都有广泛的应用。数学建模的一般步骤包括： 1. **问题理解和定义**：明确问题的背景、目标和限制条件。这一步骤涉及与领域专家和利益相关者的沟通，确保对问题的全面理解。 2. **建立数学模型**：根据问题的特性选择合适的数学方法和工具建立数学模型。模型可以是代数方程、微分方程、优化问题或概率模型等。 3. **模型分析**：对建立的数学模型进行分析，包括数学特性的探索、解的存在性和唯一性分析、稳定性分析等。这一步骤通常涉及数学理论和计算技术的结合。 4. **数值实验和模拟**：通过数值方法或计算机模拟对模型进行测试和验证，以评估模型的有效性和实用性。 5. **结果解释和评估**：将数学模型的结果与实际问题进行比较和解释，评估模型对问题的适用性和预测能力。 6. **模型优化和改进**：根据实际需求和反馈优化模型，可能涉及参数调整、模型扩展或增加复杂性等操作。 数学建模不仅需要数学知识的深度和广度，还需要对具体领域的理解和问题解决能力。成功
protobuf-3.15.0-cp39-cp39-manylinux1_x86_64.whl
06-17
Python库是一组预先编写的代码模块，旨在帮助开发者实现特定的编程任务，无需从零开始编写代码。这些库可以包括各种功能，如数学运算、文件操作、数据分析和网络编程等。Python社区提供了大量的第三方库，如NumPy、Pandas和Requests，极大地丰富了Python的应用领域，从数据科学到Web开发。Python库的丰富性是Python成为最受欢迎的编程语言之一的关键原因之一。这些库不仅为初学者提供了快速入门的途径，而且为经验丰富的开发者提供了强大的工具，以高效率、高质量地完成复杂任务。例如，Matplotlib和Seaborn库在数据可视化领域内非常受欢迎，它们提供了广泛的工具和技术，可以创建高度定制化的图表和图形，帮助数据科学家和分析师在数据探索和结果展示中更有效地传达信息。
Kotlin 简介教程.docx
06-17
Kotlin 是一门现代但已成熟的编程语言，旨在让开发人员更幸福快乐。 它简洁、安全、可与 Java 及其他语言互操作，并提供了多种方式在多个平台间复用代码，以实现高效编程
java多线程基础知识
07-28
Java多线程基础知识主要包括以下几个方面： 1. 线程的创建和启动：可以通过继承Thread类或实现Runnable接口来创建线程，并使用start()方法来启动线程。 2. 线程的生命周期：线程的生命周期包括新建、就绪、运行、...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值