JAVA 多线程

最新推荐文章于 2024-09-10 10:21:38 发布
最新推荐文章于 2024-09-10 10:21:38 发布
阅读量98 收藏
点赞数 1
分类专栏： java初级 文章标签： java 开发语言 ide Powered by 金山文档
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_50596576/article/details/129435980
版权

一， 基本概念

线程（英语：thread）

是操作系统能够进行运算调度的最小单位。它被包含在进程之中，是进程中的实 际运作单位。一条线程指的是进程中一个单一顺序的控制流，一个进程中可以并发多个线程，每条线程 并行执行不同的任务。

1.多线程 :

线程 : 程序中执行的顺序流

多线程 : 多任务执行,多路径执行

多任务之间可以实现同时执行

2. 优缺点：

  • 优点 : 提高效率,提高性能

  • 缺点 :设计更复杂,可能会造成数据不安全

了解 : 三高网站 : 高可能 高性能 高并发

3.进程与线程的区别 :

进程 : 资源分配的最小单位,每个进程都具有自己的代码与数据空间(进程上下文),进程之间的切换资源消耗大

线程 : cpu调度与执行的最小单位,一个进程至少包含1~n个线程,同一个进程的多个线程共享这个进程的代码数据空间,每个线程都有自己的运行栈与程序计数器,线程的切换消耗小

多线程的学习内容 :

线程的创建 *****

线程的状态

线程的安全 *****

线程通信

二, 线程创建方式 :

1.继承Thread类,

重写run() + start()开启线程 //run( )方法中定义线程体

注意：Class002_Thread继承Thread，故创建线程的时候，直接创建当前的对象，我们就能得到线程对象 

public class Class002_Thread extends Thread {
    /*
        定义线程体
     */
    @Override
    public void run() {
        for(int i =1;i<=20;i++){
            System.out.println("一边喝水");
            try {
                Thread.sleep(1);  //让出cpu
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) {
        //主线程
        //创建线程
        Class002_Thread th = new Class002_Thread();
        //开启线程
        th.start();  //告诉cpu,我们线程可以被调度

        for(int i =1;i<=20;i++){
            System.out.println("一边吃饭...");
            try {
                Thread.sleep(1);  //让出cpu资源
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

2.实现Runnable接口,

重写run() + start()开启线程 --> *****

优点 :

接口多实现,类只能单继承

实现资源共享

2.1 静态代理模式

HR代理角色 Manager真实角色

静态代理实现 : 代理角色与真实角色实现相同的接口 代理角色持有真实角色的引用 代理行为

new Hr(manager).addUser();

ct中重写的线程体在Class003_Thread中，直接new出来的Class003_Thread对象不是线程对象 
Class003_Thread ct = new Class003_Thread();
//创建线程对象
Thread th = new Thread(ct);

public class Class003_Thread implements Runnable{

    public static void main(String[] args) {
        Class003_Thread ct = new Class003_Thread();

        //创建线程对象
        Thread th = new Thread(ct);

        //开启线程
        th.start();


        //new Thread(new Class003_Thread()).start();

        for(int i=1;i<=20;i++){
            System.out.println("一边打游戏...");
            try {
                Thread.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    /*
        定义线程体
     */
    @Override
    public void run() {
        for(int i=1;i<=20;i++){
            System.out.println("一边陪女朋友...");
            try {
                Thread.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

2.2注意：

  • 开启线程要放在循环之前，保证循环开始之前就准备好线程的调用

  • 不能直接使用ct调用run方法，这样不是开启线程，只是普通的方法调用

  • 要通过静态代理模式实现进程的开启和准备

2.3方法重写时候的要求 :

== 方法签名

<= 返回值类型

>= 权限修饰符

异常 <= 重写方法上抛出的编译时异常类型<=被重写方法上抛出的异常的类型

class Fu{
    //void test() throws FileNotFoundException {}
    void test() throws Exception {}
}

class Zi extends Fu{
    void test() throws FileNotFoundException{
        try {
            throw new FileNotFoundException();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }
    }
}

运行时异常不会被抛出

class Fu{
    void test(){}
}

class Zi extends Fu{
    void test() throws NullPointerException{
        try {
            throw new FileNotFoundException();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }
    }
}

2.4柜台服务业务的实现

多个线程同时执行同一份资源，可能出现线程不安全的情况 
public class Class004_Practice implements Runnable{
    private int num = 1;  //业务序号 1~100
    /*
        每个柜台的服务业务
     */
    @Override
    public void run() {
        while(true){
            //线程停止的条件
            if(num>100){
                break;
            }
            System.out.println(num++ +"号用户请到"+Thread.currentThread().getName()+"办理业务....");
            try {
                Thread.sleep(2);  //模拟办理业务所需时长
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) {
        //1.一个系统,100号
        Class004_Practice cp = new Class004_Practice();

        //2.2个柜台
        Thread th1 = new Thread(cp,"一号柜台");
        Thread th2 = new Thread(cp,"二号柜台");

        //3.开启线程,必须通过同一个系统进行处理
        th1.start();
        th2.start();
    }
}

3.实现juc包下Callable接口

重写call() + 线程池 --> 了解

public class Class005_Race implements Callable<Integer> {
    //记录赢的人的名字
    private String winner = null;  //控制游戏结束,线程的结束

    /*
        返回值: 参赛者的总步数
     */
    @Override
    public Integer call() {
        for(int i=1;i<=100;i++){
            System.out.println(Thread.currentThread().getName()+"正在跑第"+i+"步....");
            try {
                Thread.sleep(2);  //模拟跑步所耗时长
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            //pool-1-thread-1是兔子
            if("pool-1-thread-1".equals(Thread.currentThread().getName()) && i%10==0){
                try {
                    Thread.sleep(10); //如果是兔子,修改10ms
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            //判断是否还要继续
            if(!checkOver(i)){
                return i;
            }
        }
        return null;
    }

    //判断是否进行下一次步
    //返回值: false比赛结束  true比赛继续
    public boolean checkOver(int step){
        if(winner!=null){
            return false;
        }
        if(step==100){
            winner = Thread.currentThread().getName();
            return false;
        }
        return true;
    }

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        //一场比赛
        Class005_Race race = new Class005_Race();
        //两个参赛者
        //1)创建一个固定大小2个线程的线程池--> 得到一个线程池提供的执行服务
        ExecutorService server = Executors.newFixedThreadPool(2);

        //2)提交任务  submit(Callable<T> task)
        Future<Integer> result1 = server.submit(race);
        Future<Integer> result2 =server.submit(race);

        //3)得到结果 V get() 该结果就是call方法的返回值
        Integer num1 = result1.get();
        Integer num2 = result2.get();
        System.out.println(num1);
        System.out.println(num2);

        //4)关闭服务
        server.shutdown();
    }
}

4.通过内部类定义线程体

public class Class006_Thread {

    //静态内部类
    static class Inner1 implements Runnable{
        @Override
        public void run() {
            for(int i=1;i<=20;i++){
                System.out.println("一边玩手机...");
                try {
                    Thread.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    public static void main(String[] args) {
        //局部内部类
        class Inner2 implements Runnable{

            @Override
            public void run() {
                for(int i=1;i<=20;i++){
                    System.out.println("一边吃饭...");
                    try {
                        Thread.sleep(1);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }

        new Thread(new Inner1()).start();
        new Thread(new Inner2()).start();

        //匿名内部类
        new Thread(new Runnable() {
            @Override
            public void run() {
                for(int i=1;i<=20;i++){
                    System.out.println("一边聊天...");
                    try {
                        Thread.sleep(1);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }).start();

        //lambda
        new Thread(()->{
            for(int i=1;i<=20;i++){
                System.out.println("一边看电视...");
                try {
                    Thread.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }).start();
    }
}

三， 线程的状态

线程的状态 : 5种

新生状态 : new
就绪状态 : start(),进入到就绪队列,等待cpu的调度
运行状态 : 当cpu调度一个线程,线程就进入到了运行状态
阻塞状态 : sleep
终止状态

1.进入到终止状态 :

  • 正常执行完毕

  • 类似stop()等方法不推荐-->已经过时

  • 添加标识判断的方式

注意 :

  • 一个线程如果一旦进入终止状态,永远不能恢复

  • 阻塞状态解除,无法立刻恢复到运行,因为需要cpu调度才能进入到运行,会直接会恢复到就绪状态

2. 进入到就绪状态 :

1.start()

2.阻塞解除

3.yield 礼让线程

4.cpu调度的切换

2.1 yeild（ ）礼让线程

yield : 礼让线程

static void yield() 向调度程序提示当前线程是否愿意产生其当前使用的处理器。

当调用yield方法,让一个线程从运行状态进入到就绪状态,让出cpu的资源

public class Class002_Yield implements Runnable{
    public static void main(String[] args) {
        Class002_Yield cy = new Class002_Yield();
        new Thread(cy,"A").start();
        new Thread(cy,"B").start();
    }
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"开始执行....");
        Thread.yield();//放大被调用的机会
        System.out.println(Thread.currentThread().getName()+"结束执行....");
    }
}

3.进入到阻塞状态 :

1.sleep()

2.join() 插队线程

3.wait() 等待

4.IO

3.1 sleep(ms) :

线程休眠,让出cpu的资源,会抱着对象的锁资源睡觉

作用 :

1.放大问题出现的可能性

2.模拟网络延迟

3.2 join（）插队线程

void join() 等待这个线程死亡。

void join(long millis) 此线程最多等待 millis毫秒。

void join(long millis, int nanos) 此线程最多等待 millis毫秒加上 nanos纳秒。

注意 : 当前线程如果被其他线程插队,当前线程就会进入到阻塞状态,等待插队线程执行完毕|等待指定时间接触阻塞

先开启线程然后插队

4. 获取线程状态

线程状态 : Thread.State getState() 返回此线程的状态。

Enum Thread.State：枚举类型的内部类

线程状态。 线程可以处于以下状态之一：

  • NEW : 新生状态

尚未启动的线程处于此状态。

  • RUNNABLE : 就绪状态

在Java虚拟机中执行的线程处于此状态。

  • BLOCKED : 等待获取锁的状态

被阻塞等待监视器锁定的线程处于此状态。

  • WAITING : wait() ,join()..

无限期等待另一个线程执行特定操作的线程处于此状态。

  • TIMED_WAITING : 与时间相关的等待 sleep(ms),join(ms),wait(ms)..

正在等待另一个线程执行最多指定等待时间的操作的线程处于此状态。

  • TERMINATED : 终止状态

已退出的线程处于此状态。

public class Class004_getState implements Runnable{

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"开始执行啦...");
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName()+"结束执行啦...");
    }

    public static void main(String[] args) throws InterruptedException {
        //创建线程
        Thread th = new Thread(new Class004_getState(),"A");

        System.out.println(th.getState());  //NEW

        th.start();
        System.out.println(th.getState());//RUNNABLE
        Thread.sleep(10);
        System.out.println(th.getState());//TIMED_WAITING
    }
}
public class Class004_getState implements Runnable{

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"开始执行啦...");
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName()+"结束执行啦...");
    }

    public static void main(String[] args) throws InterruptedException {
        //创建线程
        Thread th = new Thread(new Class004_getState(),"A");

        System.out.println(th.getState());  //NEW

        th.start();
        while(true){
            Thread.sleep(10);
            System.out.println(th.getState());

            if(th.getState()==Thread.State.TERMINATED){
                break;
            }
        }
    }
}

四，了解线程 : 线程的分类

用户线程 :

创建的所有线程默认都为用户线程

所有的用户线程全部执行完毕,程序才会终止

守护线程 : 用来守护用户线程的

需要手动设置

void setDaemon(boolean on) 将此线程标记为 daemon线程或用户线程。

当所有的用户线程执行完毕,守护线程会自动停止

注意 :

垃圾回收机制就是典型的守护线程

先设置守护再设置就绪

public class Class005_Daemon implements Runnable {
    @Override
    public void run() {
        while(true){
            try {
                Thread.sleep(5);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("守护线程.....");
        }
    }

    public static void main(String[] args) {
        //主线程 : 用户线程

        Thread th = new Thread(new Class005_Daemon());;
        //设置守护线程
        th.setDaemon(true);
        //就绪
        th.start();

        for(int i=1;i<=10;i++){
            System.out.println(i);
            try {
                Thread.sleep(2);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

    }
}

五，线程优先级 : Priority 1~10 了解

不一定优先级较大的先执行，因为可能先开启的先执行

放大线程优先执行的概率

默认优先级 : 5

static int MAX_PRIORITY 线程可以拥有的最大优先级。

static int MIN_PRIORITY 线程可以拥有的最低优先级。

static int NORM_PRIORITY 分配给线程的默认优先级。

void setPriority(int newPriority) 更改此线程的优先级。

int getPriority() 返回此线程的优先级。

public class Class006_Priority implements Runnable{

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"执行了....");
    }

    public static void main(String[] args) {
        Class006_Priority  cp = new Class006_Priority();
        Thread th1 = new Thread(cp,"A");
        Thread th2 = new Thread(cp,"B");
        Thread th3 = new Thread(cp,"C");

        th1.setPriority(1);
        th3.setPriority(Thread.MAX_PRIORITY);

        System.out.println(th1.getPriority());
        System.out.println(th2.getPriority());
        System.out.println(th3.getPriority());

        th1.start();
        th2.start();
        th3.start();
    }
}

六， interrupt

void interrupt() 为线程添加中断标识。

boolean isInterrupted() 测试此线程是否已被中断,是否曾经调用过interrupt方法添加了中断标识,是返回true,不是返回false。

static boolean interrupted() 测试当前正在执行的线程是否已被中断,是否曾经调用过interrupt方法添加了中断标识,是返回true,不是返回false。同时会复位标识

注意 :

sleep方法让一个线程处于指定时间的休眠状态时,如果有任何线程中断了当前线程,调用interrupt方法添加了中断标识,遇到InterruptedException - 。 抛出此异常时，将清除当前线程的中断状态 。

线程安全 :

多个线程同时操作同一份资源,才有可能出现线程不安全问题

同步锁 synchronized : 让多个执行可能会造成数据不安全的代码段时排队执行

同步的条件 : 协调多线程排队执行的条件 --> 对象锁

对象在使用之前要求已经创建|存在

引用指向的对象不能改变

同步的代码段 : 多个线程之间需要排队执行的代码段

同步的代码范围过大,效率低

同步的代码范围过小,锁不住

使用语法 :

同步方法 : 在方法上使用synchronized修饰

同步的代码段为整个方法体

成员方法 : 锁的是调用成员方法的对象

静态方法 : 锁的是类的Class对象

同步块 :

synchronized(条件){

同步的代码段;

}

条件 : 类的Class对象,this,资源对象

线程通信 :

每个线程之间的执行互不影响,想要通过线程通信实现多个线程的执行好似商量好符合逻辑需求

通过线程通信实现生产者消费者模式

wait() notify() notifyAll() 配合使用,在同步环境下使用

对象.wait() 当前正在执行的线程就会进入到与对象相关的等待池中进行等待,等待被唤醒,这是一种阻塞状态

让出cpu的资源同时让出对象的锁

对象.notify() 唤醒对象等待中正在等在的线程,被唤醒的线程会从阻塞恢复到就绪状态,等待cpu的调用并同时获取对象的锁才能执行

注意 : 以上的方法要求使用在同步环境下,作用是协调多线程对共享数据存储问题,否则会遇到异常java.lang.IllegalMonitorStateException

通过信号灯法模拟人车共用街道

Street 街道 信号灯boolean ns南北 we东西

人 : true绿灯:ns南北

车 : false:红灯:we东西

异步/同步

阻塞/非阻塞

并行/并发

qq_50596576
关注
专栏目录
java多线程QQ
01-05
java多线程和java通信实现的qq聊天。多线程网络qq聊天。socket，java网络通信，等多种技术集为一体
Java 多线程编程
lighter
04-04 748
Java给多线程编程提供了内置的支持。一个多线程程序包含两个或多个能并发运行的部分。程序的每一部分都称作一个线程，并且每个线程定义了一个独立的执行路径。 多线程是多任务的一种特别的形式。多线程比多任务需要更小的开销。 这里定义和线程相关的另一个术语：进程：一个进程包括由操作系统分配的内存空间，包含一个或多个线程。一个线程不能独立的存在，它必须是进程的一部分。一个进程一直运行，直到所有的非守候线
Java之多线程
gigidawang的博客
09-01 241
java之多线程，包括多线程的创建、线程安全问题的处理、线程间的通信等
网络多线程编程-简单实现（模拟QQ的实现）
weixin_52234647的博客
09-03 690
1.项目框架的设计 2.java面向对象编程 3.网络编程 4.多线程编程 5.IO流的操作 6.Mysql/先使用集合来充当内存数据库 核心功能的实现，界面的优化还是自己把握 项目吃透的意义: 1.网络编程 2.IO编程 3.面向对象的编程 4.多线程的管理 是对于这些的综合运用 用户分析： 界面带上 1.用户登录 2.拉取在线用户列表 3.无异常退出（客户端，服务端) 因为是通过网络进行控制的 4.私聊的实现 5.群聊的实现 （公网的实现） 6.发文件的实现：关键是给谁发送过去信息是关键 7.文件服
深入理解Java多线程（一）
qq_37438740的博客
08-11 4万+
关于java多线程的概念以及基本用法：java多线程基础 1，停止线程 停止线程意味着在线程执行完之前停止正在做的操作，即立刻放弃当前的操作，这并不容易。停止线程可以用Thread.stop()方法，但是这个方法不安全，所以不建议使用，还有一个方法就是Thread.interrupt()方法，但是这个方法不会终止一个正在运行的线程，需要添加一个判断才可以完成线程的停止 1.1，...
Java多线程超详解
热门推荐
weixin_44797490的博客
06-11 14万+
引言 随着计算机的配置越来越高，我们需要将进程进一步优化，细分为线程，充分提高图形化界面的多线程的开发。这就要求对线程的掌握很彻底。 那么话不多说，今天本帅将记录自己线程的学习。 线程的相关API //获取当前线程的名字 Thread.currentThread().getName() 1.start():1.启动当前线程2.调用线程中的run方法 2.run():通常需要重写Thread类中的此...
单核 CPU 支持 Java 多线程吗？我们来一起看看吧
吴名氏的博客
06-09 9万+
单核 CPU 支持 Java 多线程吗？我们来一起看看吧
java多线程编程实例
延陵缥缈的博客
05-25 8万+
        这篇文章主要介绍了java多线程编程实例，分享了几则多线程的实例代码，具有一定参考价值，加深多线程编程的理解还是很有帮助的，需要的朋友可以参考下。1.相关知识：Java多线程程序设计到的知识：（1）对同一个数量进行操作（2）对同一个对象进行操作（3）回调方法使用（4）线程同步，死锁问题（5）线程通信等等2．示例2.1三个售票窗口同时出售20张票程序分析：    (1)票数要使用同一...
Java 多线程 测试
风信子
04-14 1944
Java 多线程 测试1 Callable2 Runnable3 Thread 1 Callable package com.xu.thread; import java.util.concurrent.Callable; /** * @author Administrator */ public class MyCallable implements Callable { @Override public Object call() throws Exception {
详解Java多线程处理List数据
08-26
详解Java多线程处理List数据 Java多线程处理List数据是指在Java编程中，使用多线程技术来处理List数据的操作。这种操作可以提高程序的执行效率和性能，特别是在处理大规模数据时。下面将详细介绍Java多线程处理List...
JAVA多线程的使用场景与注意事项总结
08-26
JAVA多线程的使用场景与注意事项总结 Java多线程是Java语言中的一种重要机制，允许程序同时执行多个任务，以提高程序的执行效率和响应速度。在Java中，多线程可以通过继承Thread类、实现Runnable接口或使用线程池来...
java多线程实现大批量数据导入源码
09-29
本项目以"java多线程实现大批量数据导入源码"为题，旨在通过多线程策略将大量数据切分，并进行并行处理，以提高数据处理速度。 首先，我们需要理解Java中的线程机制。Java通过`Thread`类来创建和管理线程。每个线程...
Java多线程Executors批量执行数据实现限流
05-20
Java多线程实现数据切割批量执行，实现限流操作。 java线程池Executors实现数据批量操作。 批量异步Executors处理数据，实现限流操作，QPS限流。 线程池调用第三方接口限流实现逻辑。 案例适合： 1.批量处理大数据。...
java多线程导出excel（千万级别）优化
12-05
Java多线程导出Excel是处理大数据量时的一种高效策略，尤其在面对千万级别的数据时。传统的Apache POI库在处理大规模数据时可能会遇到栈溢出（StackOverflowError）和内存溢出（OutOfMemoryError）等问题，因为这些...
【Java篇】多线程详解
zhangxia_的博客
05-19 1万+
Java系统在语言层次上对多线程直接提供支持，多线程的主要目的是将一个程序中的各个程序段并发化，在在通常情况下，Java程序各部分是按顺序一次执行的，由于某种原因，需要将这些按顺序执行的程序段转化为并发执行，每个程序段在逻辑上是相互完整的代码段。实际上，在单处理器上，同一时刻只能执行一个代码，但是在同一时间段内，这些代码交替执行，所谓的“微观串行，宏观并行”。...
spring事务详细讲解-深入浅出
小电玩
09-08 539
Spring 事务是本身就是对数据库的事务的支持，没有数据库的事务 Spring 是本身无法实现事务的。Spring只提供了统一事务管理接口，具体的实现还是由各数据库自己实现。在使用 Spring 事务时，可以通过注解或编程方式将需要进行事务管理的方法和代码块标记为事务性操作，当这些操作被执行时，Spring 会负责开启时根据当前环境中设置的隔离级别，调整数据库隔离级别。
Java多线程：深入探索与详细解析
m0_63550220的博客
09-08 1523
作为Java中的基本执行单元，线程是轻量级的进程，由线程ID、程序计数器、Java虚拟机栈、本地方法栈、和线程私有内存等部分组成。每个线程都有独立的执行路径，但共享进程的资源（如内存）。：进程是系统资源分配的基本单位，它包含了一个或多个线程以及这些线程运行所需的资源。在Java中，JVM（Java虚拟机）就是一个进程，而运行在JVM上的多个线程则共享JVM的内存空间。：并发指的是多个任务在同一时间段内交替执行，而并行则指的是多个任务在同一时刻真正同时执行。
Java集合：Stack详解
最新发布
yang_brother的博客
09-10 587
Java 中的Stack类是一个后进先出（LIFO, Last In First Out）的数据结构，它继承自Vector类。尽管Stack是一个可用的类，但它被认为是遗留的，并且在新代码中不推荐使用。通常建议使用Deque或ArrayDeque作为替代。
币安/OK现货合约量化系统APP开发
I592O929783的博客
09-08 621
后端：考虑系统需要处理大量实时数据和高频交易的特点，选择高性能的编程语言和技术框架，如Python的Django或Flask框架，Java的Spring Boot等。用户交互界面：设计直观易用的用户交互界面，包括交易界面、策略配置界面、风险管理界面等，方便用户进行交易操作、策略配置和风险管理。市场数据接入：开发市场数据接入模块，从币安等交易所或数据服务商获取实时的市场数据，包括行情数据、订单簿数据、成交数据等。前端：选择适合开发复杂界面的前端框架，如React、Vue.js等，以提供用户友好的交互界面。
Java多线程深度解析
"《Java多线程详解》- 汪文君" 本书是关于Java多线程编程的深度解析，作者汪文君分享了他在工作中和学习中的理解和实践经验。书中内容详细介绍了多线程的基本概念、Java对多线程的支持以及如何在实际编程中运用多...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值