Day18/Day19/Day20——网络编程Socket、多线程、Map、反射

已于 2024-04-01 20:07:21 修改
阅读量762 收藏 29
点赞数 22
分类专栏： Java学习 文章标签： java 开发语言 网络
于 2024-04-01 20:04:47 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/MF956/article/details/137244756
版权

Day18

网络编程

java.net.Socket是Java提供的用于进行网络编程的API

Socket编程可以让软件与软件之间以计算机为载体，以网络作为信息流动的通道进行远端数据传输

Socket

Socket中封装了TCP协议的通讯细节，使用它可以和远端计算机建立网络连接，并基于两条流（一条输入一条输出）的读写与对方进行数据交换

  1. 网络通信标准API；
  2. 进行可靠的网络通讯

image-20240328115330787

Socket通讯

两端只有两个插口，中间实现过程不关注，只关注两端的插座

Socket通讯原理

IP地址

IP地址用于标识网络上的计算机·

IP地址唯一标识计算机

端口号

计算机内部对各个程序进行唯一标识，端口号就是每个程序的唯一标识

端口号程序唯一标识

[!NOTE]

通讯时使用 ”IP+端口号“ 做到计算机之间的精确访问

客户端与服务端（c/s）

  • 谁发起请求谁就是客户端，谁接收请求就是服务端
  • 客户端与服务端之间为多对一的关系

image-20240328120011320

客户端与服务端为不对等的，服务端的总机有许多Socket，用于满足客户端的访问需求

image-20240328140420418

ServerSocket

java.net.ServerSocket

  • 运行在服务端，相当于客户中心的总机，上面有若干插座（Socket），客户端与服务端连接就是与总机的插座连接，总机分配一个插座与之连接，保持双方通讯

ServerSocket的主要工作

  1. 创建时向系统申请服务端口，以便客户端可以通过端口找到
  2. 监听该端口，一旦一个客户端连接，便创建一个Socket，通过它与客户端通讯
常用方法
accept()
  • 该方法为一个阻塞方法，调用后程序会暂停等待客户端使用Socket与之连接，此时accept会立即返回一个Socket通过返回的Socket就可以与连接的客户端双向通讯了
  • 多次调用accept方法可以连接多个客户端

示例

try {
    System.out.println("等待客户端连接...");
    Socket socket = serverSocket.accept();
    System.out.println("一个客户端已连接");
} catch (IOException e) {
    e.printStackTrace();
    System.out.println("连接建立失败");
}

客户端发送消息给服务端

原理

image-20240328160430981

实现

try {
    OutputStream outputStream = socket.getOutputStream();
    //构建四层输出流
    OutputStreamWriter outputStreamWriter = new OutputStreamWriter(outputStream,StandardCharsets.UTF_8);
    BufferedWriter bufferedWriter = new BufferedWriter(outputStreamWriter);
    PrintWriter printWriter = new PrintWriter(bufferedWriter,true);
    printWriter.println("你好！");
} catch (IOException e) {
    e.printStackTrace();
    System.out.println("获取输出流失败");
}

服务端接收客户端消息

原理

image-20240328160627402

实现

try {
    System.out.println("等待客户端连接...");
    Socket socket = serverSocket.accept();
    System.out.println("一个客户端已连接");
    //构建三层文件接收流
    InputStream inputStream = socket.getInputStream();
    InputStreamReader inputStreamReader = new InputStreamReader(inputStream);
    BufferedReader bufferedReader = new BufferedReader(inputStreamReader);
    String line = bufferedReader.readLine();
    System.out.println("客户端发来的消息是：" + line);
      int d = inputStream.read();
      System.out.println(d);
} catch (IOException e) {
    e.printStackTrace();
    System.out.println("连接建立失败");
}

TCP和UDP

TCP和UDP的区别
  • TCP丢包会重发，UDP丢包不会重发
  • TCP传输会继续多次验证，丢包率低
  • UDP单向传输，只发送一次
  • TCP常用于少量数据传输，例如网站请求发送
  • UDP常用于极大量数据发送，例如视频信号
TCP三次握手

三次握手用于基于TCP进行连接时使用的建立可靠连接方式，通过客户端于服务端之间的三次通讯可以建立较为稳定的网络连接用于通讯

原理

TCP三次握手

代码实现

代码中新建客户端Socket后会自动与服务端建立三次握手，保证可靠连接

new Socket(String host, int port)
TCP四次挥手

四次挥手用于基于TCP的网络连接在断开连接时使用的方式，通过客户端与服务端之间的四次通讯保证服务端的数据已完整的传输给客户端，避免了因结束通讯而导致数据丢包，提高了连接的稳定性

原理

TCP四次握手

代码实现

在客户端finally中添加close四次挥手代码，保证不管何时断开连接都会进行

try {
    socket.close();//TCP四次挥手，释放资源
    System.out.println("客户端已退出");
} catch (IOException e) {
    e.printStackTrace();
}

Day19

多线程

线程

程序中一个单一的顺序执行流程

顺序执行

image-20240329092530495

弊端：代码之间耦合太高，一块执行失败则全局失败

并发执行

image-20240329092626425

原理：

  • CPU一次只能执行一条指令
  • 微观上走走停停，宏观上都在运行，视为并发，不是绝对意义上的“同时运行”
  • 操作系统中的线程调度器将时间划分成很多时间块，尽可能均分给各个线程
多线程使用场景
  1. 多线程用于在一个程序中需要同时处理多个互不干扰的任务
  2. 多线程可以加快程序运行速度
多核并发

一块cpu上集成多个核心，即多个cpu放在一个主板上，即可真正实现多线程并行运行

image-20240329094836576

创建并启动线程

方式一
  1. 定义一个类继承Thread
  2. 重写run方法来定义线程要执行的任务代码
  3. 调用线程的start方法启动线程（不可主动调run方法）
public class TheadDemo1 {
    public static void main(String[] args) {
        new MyThread0().start();
        new MyThread1().start();
    }
}
class MyThread0 extends Thread{
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println("线程名："+Thread.currentThread().getName()+"\ti="+(i+1));
        }
    }
}
class MyThread1 extends  Thread{
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println("线程名："+Thread.currentThread().getName()+"\ti="+(i+1));
        }
    }
}

方式一弊端：

  • 继承冲突问题：Java中为单继承规则，继承了线程Thread则不能继承其他类了
  • 线程和线程任务之间存在耦合：会导致线程的重用性变低
方式二

该方式可以避免直接继承Thread类导致的继承冲突问题

  1. 类实现Runnable接口，并重写run方法
  2. 实例化要并发执行的任务
  3. 使用任务实例化线程
public class ThreadDemo2 {
    public static void main(String[] args) {
        /*
            实例化线程要并发执行的任务
         */
        MyRunnable0 runnable0 = new MyRunnable0();
        MyRunnable1 runnable1 = new MyRunnable1();
        /*
            实例化线程
         */
        new Thread(runnable0).start();
        new Thread(runnable1).start();
    }
}
class MyRunnable0 implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println("线程1:\t"+i);
        }
    }
}
class MyRunnable1 extends Thread{
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println("*****线程2:\t"+i);
        }
    }
}

简化写法

Thread t3 = new Thread(() -> b2.doSome());
Thread t2 = new Thread(b2::doSome);

[!NOTE]

@FunctionalInterface

Java中标注该注解的类均可以使用lambda表达式创建

主线程

static Thread currentThread()
静态方法，使用Thread类名直接调用，返回对当前正在执行的线程对象的引用。

  • java中所有代码都是线程运行的，main方法也不例外
  • JVM启动后会自动创建一个名为main的线程，main方法就是在main线程中执行的，称为主线程
public static void main(String[] args) {
    Thread thread = Thread.currentThread();
    System.out.println("主线程名称：" + thread.getName());//主线程名称：main
}

在方法中调用currentThread方法时无法直接指定线程，在运行时谁调用了该方法，则指向的就是哪个线程

public static void main(String[] args) {
    showInfo();//指向main主线程，输出——>当前线程名称：main
}
private static void showInfo() {
    Thread currentThread = Thread.currentThread();
    System.out.println("当前线程名称：" + currentThread.getName());
}

线程常见命令

//获取线程基本信息
String threadName = thread.getName();//获取线程名
long threadId = thread.getId();//获取线程id
int threadPriority = thread.getPriority();//获取线程优先级,线程默认优先级为5，优先级范围为1~10

//判断线程状态
boolean alive = thread.isAlive();//获取线程是否存活，线程run方法执行完线程就会被杀死
boolean daemon = thread.isDaemon();//获取线程是否为守护线程
boolean interrupted = thread.isInterrupted();//获取线程是否被中断

补充——从A类向B类的方法中传参

  1. 通过在B类中添加B类的构造方法（含所需参数），
  2. 在A类中实例化B类对象时，将参数传给B类

设置线程优先级

调用setPriority方法设置线程的优先级，优先级越高执行次数越多

thread1.setPriority(Thread.MIN_PRIORITY);
thread2.setPriority(Thread.NORM_PRIORITY);
thread3.setPriority(Thread.MAX_PRIORITY);

  • 优先级最小值MIN_PRIORITY：1

  • 优先级最大值MAX_PRIORITY：10

  • 优先级默认值NORM_PRIORITY（线程创建默认）：5

线程和进程的区别

  1. 线程是进程内的执行单元，一个线程中可以有多个进程，多个线程共享同一进程的资源

  2. 线程是一个动态概念，是程序中一个单一的顺序执行流程

    进程时一个静态概念，是操作系统分配资源的基本单位

  3. 创建、切换和销毁进程的开销比较大，需要分配和回收整个进程自身的资源

    创建、切换和销毁线程的开销相对较小，线程共享进程的资源，只需分配和回收栈和寄存器等线程私有的资源

  4. 多个进程可以同时进行，每个进程都拥有自己的的地址空间，互不干扰

    多个线程共享同一进程的资源，可以并发执行，但可能需要同步和互斥来确保数据一致性

守护线程

  • 守护线程的特点是：当进程中只剩下守护线程时，所有守护线程强制终止

  • GC就是运行在一个守护线程上的

  • 正常常见线程时，默认都是用户线程。

  • 通过setDaemon方法将线程设置为守护线程，设置守护线程的操作必须在线程执行前进行

    jack.setDaemon(true);
jack.start();

  • 守护线程通常用于执行后台任务，比如垃圾回收线程。

  • 守护线程与用户线程的区别在于，当进程中不存在任何用户线程时，守护线程会自动结束。

  • 主线程是用户线程，在main方法中线程启动后主线程立即死亡

  • 守护线程没有针对性，只有进程中的所有用户线程全部死亡，守护线程才会死亡，只要有用户线程还在，就不会杀死守护线程

线程阻塞

调用静态方法sleep对线程进行固定时间阻塞

该方法声明抛出一个InterruptedException异常，需要对该异常进行捕获并处理

方法格式

public static native void sleep(long millis) throws InterruptedException;
  • 线程休眠sleep阻塞
  • 让线程休眠指定的毫秒数，进入阻塞状态。
  • 阻塞时间结束，线程自动苏醒进入就绪状态，等待CPU调度。
//倒计时，每隔1秒输出一个数字
for (int i = 5; i > 0; i--){
    try {
        Thread.sleep(1000);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    System.out.println(i);
}

线程唤醒

  1. 一个线程中使用sleep方法进行长时间的线程阻塞，并捕获InterruptedException异常

  2. 在另一个线程中添加interrupt方法将其唤醒，使用interrupt方法可以终端一条正在sleep阻塞的线程，此时sleep方法会立即抛出中断异常（唤醒），并执行中断处理代码

  3. 注：被唤醒的线程应该在前，否则后者无法访问到被唤醒线程

    Thread thread1 = new Thread(){
    try{
        //...
        sleep(10000000000);
    } catch(InterruptedException e){
        //唤醒后的操作
    }
};

Thread thread2 = new Thread(){
    try{
        //...
    } catch(InterruptedException e){
        throw new RuntimeException(e);
    }
    thread1.interrupt
};

线程的生命周期

线程的生命周期

调用yield方法可以让线程将剩余时间片直接释放

Thread.yield();

线程并发安全问题

  • 当多个线程并发操作同一资源，由于线程切换的时机不确定，导致执行顺序出现混乱产生不良后果
  • 临界资源：操作该资源的完成过程同一时刻只能被单个线程进行
  • 常见临界资源：多线程共享实例变量、多线程共享静态公共变量

线程共享临界资源

解决并发问题

synchronized锁的时对应的对象

方法1

弊端：对于方法中不需要同步执行的操作，会导致运行速度大大降低，浪费cpu资源

  • 将异步运行转换为同步运行，即排队运行
  • 在方法上加synchronized关键字，将该方法转变为同步方法
public synchronized boolean getMoney(int money){
    if (money<=getAccount()){
        this.account -= money;
          Thread.yield();
        save(account);
        return true;
    }
    return false;
}
方法2
  • 通过精确化同步范围，将固定的操作代码转为同步，可以避免非必要同步代码也同步执行
  • 在需要同步的操作代码上加synchronized代码块

方法格式

参数可以传this或字符串直接量（“123”）

参数有效条件

  1. 引用类型
  2. 需要排队执行该代码的线程看到的都是一个对象（字符串直接量创建时放在常量池中，所以所有线程看到的是同一个）
  3. 在成员方法上使用synchronized时只能使用this
  4. 静态方法使用synchronized时同步监视器对象依然只能用this
  5. 当使用synchronized关键字修饰一个静态方法时，它将锁定整个类。这意味着当一个线程调用该方法时，其他线程将无法访问该类的任何静态方法，直到第一个线程完成对该方法的调用。即当一个线程调用静态方法时，它一定是同步的
  6. 静态方法中也可以使用synchronized代码块
synchronized(this){ //this指的是buy方法的所属对象
    ...
}

示例

void buy(){
    try {
        Thread thread = Thread.currentThread();
        String name = thread.getName();
        System.out.println(name+" 正在挑衣服...");
        Thread.sleep(5000);
        //使用同步代码块缩小同步范围
        synchronized (this) { //this指的是buy方法的所属对象
            System.out.println(name+" 正在试衣服...");
            Thread.sleep(5000);
        }
        System.out.println(name+" 结账离开...");
    } catch (InterruptedException e) {
        throw new RuntimeException(e);
    }

StringBuild和StringBuffer

  • StringBuffer是线程安全的，而StringBuilder不是线程安全的。
  • StringBuffer的方法中加入了同步锁synchronized，而StringBuilder的方法中则没有加入同步锁。
  • StringBuffer是线程安全的，在多线程环境下，可以用来保证线程安全，而StringBuilder不是线程安全的，在多线程环境下，不能保证线程安全。
public StringBuilder append(String str) {
    super.append(str);
    return this;
}

public synchronized StringBuffer append(String str) {
    toStringCache = null;
    super.append(str);
    return this;
}

集合在并发场景的操作

  • ArrayList、LinkedList、HashSet均不是线程安全的，在多线程场景下均无法正常使用
  • Collections类中有synchronizedXxx方法可以将对应的集合转为并发集合，需要将一个对应的普通集合作为参数传入方法中
HashSet<Object> set = new HashSet<>();
Set<Object> synchronizedSet = Collections.synchronizedSet(set);

互斥锁

  • 当使用多个synchronized方法时，但是指定的同步监视器对象时同一个类，此时虽然对象调的时不同的方法，也需要同步排队执行
  • 保证多个线程调用的是同一个同步监视器对象，否则无法保证互斥性。
public class SyncDemo6 {
    public static void main(String[] args) {
        Foo foo = new Foo();
        Thread t1 = new Thread(foo::Method1);
        Thread t2 = new Thread(foo::Method2);
        t1.start();
        t2.start();
    }
}
class Foo{
    public synchronized void Method1(){
        Thread thread = Thread.currentThread();
        String threadName = thread.getName();
        System.out.println(threadName + "开始执行Method1");
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        System.out.println(threadName + "执行Method1完毕");
    }
    public synchronized void Method2(){
        Thread thread = Thread.currentThread();
        String threadName = thread.getName();
        System.out.println(threadName + "开始执行Method2");
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        System.out.println(threadName + "执行Method2完毕");
    }
}

Day20

Map接口

java.util.Map查找表

  1. Map是Java集合框架的成员
  2. Map是一种把键对象和值对象进行关联的对象。
  3. Map中不能包含重复的键；每个键都对应一个值。
  4. Map集合没有迭代器，但是可以通过entrySet()方法提取出key/value组成的Set集合中使用迭代器
  5. Map集合判断两个对象相等的标准是：两个对象通过equals()方法返回true。

结构

keyvalue
……

特点

  • key不允许重复
  • 以key-value成对保存数据
  • 根据key获取对应的value，key可以看成的value的索引

分类

根据内部数据结构不同，Map接口有很多实现类

  1. 内部为hash表实现为HashMap
  2. 内部使用链表维护顺序的HashMap是LinkedHashMap
  3. 内部为排序二叉树实现的是TreeMap

常用方法

  • 使用put方法向已存在的key中添加value，会覆盖原value，并返回旧value
  • 要使用包装类接收，避免空指针异常，因为若使用基本类型接收时，返回时会自动拆箱，若key不存在，则value为null，使用null拆箱会抛出异常
V put(K key, V value); //增
V get(Object key); //查
int size(); //获取map的大小
boolean isEmpty(); //判空
V remove(Object key); //删除键值对，返回被删元素对应的value
boolean containsKey(Object key); //判断指定key是否存在
boolean containsValue(Object value); //判断指定值value是否存在

map的遍历

  1. 只遍历key

    Set<String> keySet = hashMap.keySet();
keySet.stream()
    .map(x->"key:"+x).forEach(System.out::println);

  2. 只遍历value

    hashMap.values().stream()
        .map(x->"value:"+x)
        .forEach(System.out::println);

  3. 遍历key和value

    hashMap.entrySet().stream()
        .map(x->"key:"+x.getKey()+" value:"+x.getValue())
        .forEach(System.out::println);

  4. JDK8之后可以使用Lambda表达式对Map进行遍历

    hashMap.forEach((x, y) -> System.out.println("key:" + x + "  value:" + y));

  5. 使用迭代器

    ​ Map集合没有迭代器，但是可以通过entrySet()方法提取出key/value组成的Set集合中使用迭代器

    Iterator<HashMap.Entry<String, Integer>> iterator = hashMap.entrySet().iterator();

  6. 使用增强for循环

    for (Map.Entry<String, Integer> entry : hashMap.entrySet()) {
    System.out.println("key:" + entry.getKey() + "  value:" + entry.getValue());
}

反射

  • 反射是Java的动态机制
  • 反射机制允许程序在运行期间确定对象实例化，方法调用，属性操作
  • 反射机制可提高代码的灵活度，但运行效率慢，开销大，不能过度依赖反射
  • Java大部分的框架中都使用了反射机制

Class类

  1. JVM中每个被加载的类都有且只有一个Class实例
  2. Class类的构造器是私有的，开发者不能主动实例化Class类的对象
  3. Class类的对象仅能由JVM创建

常用方法

  • 获取类全限定名（包名.类名）

    stringClass.getName();

  • 仅获取类名

    stringClass.getSimpleName();

  • 获取包信息

    Package aPackage = stringClass.getPackage();
String packageName = aPackage.getName();

  • 获取类中所有公开方法

    Method[] methods = stringClass.getMethods();
System.out.println("String类中所有公开方法有 " + methods.length+" 个");
for (Method method : methods) {
    System.out.println(method.getName());
}

  • 使用forName创建反射

    注：使用forName创建反射时需要输入字符串格式的类全限定名（包名.类名）

    Scanner sc = new Scanner(System.in);
String className = sc.nextLine();
System.out.println("请输入要创建对象的全限定名");
Class<?> aClass = Class.forName(className);
MF956
关注
  • 22
    点赞
  • 踩
  • 29
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Day14--注解+反射+socket
weixin_47307932的博客
12-26 83
Day14–注解+反射+socket 一、注解 1.概述 ​ 标志是@ ,英文叫Annotation,可以用现成的已经存在的,也可以自定义注解. 2.分类 ​ --jdk提供的5个 ​ --元注解5个 3.元注解 ​ --配合完成自定义注解 ​ --@Target: 指定注解可以出现的位置 ​ --ElementType工具类维护了具体的值,方法上,变量上,类上… ​ --@Retention:指定注解的生命周期 ​ --RetentionPolicy工具类维护了具体的值,源码中,clas
day23_网络编程.pdf
11-02
day23_网络编程.pdf
【Java基础】多线程、TCP/UDP网络编程
雨下一整晚real的博客
06-07 520
七、多线程 实现多线程 进程和线程 进程：是系统正在运行的程序， 系统进行资源分配和独立调用的基本单位； 每一个进程都有它自己的内存空间和系统资源； 线程：是进程中的单个顺序控制流，是一条执行路径 单线程：一个进程中只有一条执行路径，则称为单线程程序 多线程：一个进程中如果有多条执行路径，则成为多线程程序 实现多线程 方式一：继承Thread类 创建MyThread类继承Thread类 重写Thread类中的run()方法 创建MyThread类对象 启动线程 public class MyTh
学习JavaEE的日子 Day38 网络编程
weixin_69595694的博客
04-14 846
实现多台计算机之间实现数据的共享和传递，网络应用程序主要组成为：网络编程+IO流+多线程。
Java学习日志Day26_Properties属性集合类_网络Socket编程
igfff的博客
06-04 100
一、Properties属性集合类 /* Properties 继承自Hashtable<K,V>---->实现Map<K,V>接口 表示了一个持久的属性集 *Properties 可保存在流中或从流中加载。属性列表中每个键及其对应值都是一个字符串。 * 构造方法 public Properties() */ public class PropertiesDemo { public static void main(String[] args) { //
week6 day4 并发编程之多线程 代码
weixin_53587094的博客
03-03 234
week6 day4 并发编程之多线程 代码一、threading模块介绍二、开启线程的两种方式2.1 方式一2.2 方式二：自定义类三、在一个进程下开启多个线程与在一个进程下开设多个子进程的区别四、练习4.1 练习一：之前客户端和服务端并发4.2 练习二：三个任务，一个接受用户输入，一个将用户输入的内容转换成大写，一个将格式化后的结果存入文件五、线程相关的其他方法六、守护线程七、Python GIL（Global Interpreter Lock）7.1 介绍7.2 GIL介绍7.3 GIL与Lock7.
Python笔记day39（并发）|回调函数爬虫例子、多线程、多线程socket聊天
拼搏的小白
08-28 661
1，内容回顾 # 今天和明天 多线程 # 协程 + IO模型 # 管道 # 数据的共享 Manager dict list # 进程池 # cpu个数+1 # ret = map(func,iterable) # 异步 自带close和join # 所有结果的[] # apply # 同步的:只有当func执行完之后...
【大数据开发】Java语言基础——TCP编程、Stream流式操作day23
白色风车
07-29 212
一、知识准备 二、TCP编程 1.TCP客户端步骤 package day23.tcp1; import java.io.IOException; import java.io.InputStream; import java.io.OutputStream; import java.net.InetAddress; import java.net.Socket; public class TcpClient { public static void main(String[] args)
【26天高效学习Java编程】Day23：Java中Socket网络编程NIO,AIO详解
Learning_xzj的博客
05-19 558
<stron本专栏将从基础开始，循序渐进，由浅入深讲解Java的基本使用，希望大家都能够从中有所收获，也请大家多多支持。 专栏地址:26天高效学习Java编程 相关软件地址:软件地址 所有代码地址:代码地址 如果文章知识点有错误的地方，请指正！大家一起学习，一起进步。 如果感觉博主的文章还不错的话，还请关注、点赞、收藏三连支持一下博主哦 文章目录本文内容第一章 网络编程入门知识点--软件结构目标路径讲解知识点--网络编程三要素目标路径讲解协议IP地址端口号小结知识点--InetAddre.
Day794.如何用协程来优化多线程业务 -Java 性能调优实战
阿昌爱Java
11-08 396
协程有个队列，最终还是需要主线程来调度执行。那是不是有点类似线程池。主线程是Worker线程，每一个协程就是一个Task。只不过主线程执行到的某个Task阻塞时会去执行下一个Task。协程和线程密切相关，协程可以认为是运行在线程上的代码块，协程提供的挂起操作会使协程暂停执行，而不会导致线程阻塞。协程又是一种轻量级资源，即使创建了上千个协程，对于系统来说也不是很大的负担，但如果在程序中创建上千个线程，那系统可真就压力山大了。可以说，协程的设计方式极大地提高了线程的使用率。
DAY3 网络编程 多点通信
10-20
DAY3 网络编程 多点通信
python网络编程DAY02.txt
04-27
套接字 ： 网络编程方式 流式套接字：tcp 数据报套接字： udp tcp服务端流程 socket() ---> bind() ---> listen() ---> accept()---> recv/send ---> close() 客户端 socket() ---> connect() ---> send/recv --->...
day18_等待唤醒、JMM、并发编程特性、volatile.pdf
11-02
day18_等待唤醒、JMM、并发编程特性、volatile.pdf
day03.rar_Linux/Unix编程_Unix_Linux_
08-11
这是一个在linux系统下求平均数的简单小程序，希望对初接触linux的同学有用
jar包增量更新分析
junlaiyan的专栏
05-16 251
借助jdeps分析出jar包的增量文件
java实现拼图小游戏
monkey108的博客
05-16 616
本文主要提供用java实现的拼图小游戏源代码。
c【语言】了解指针，爱上指针（1）
最新发布
yzqy_的博客
05-16 899
在计算机中，数据是存储在内存中的，cpu从内存中读取数据，为了方便读取数据，内存又被划分为了一个个的内存单元，一个内存单元的大小就是一字节，一字节等于8bit位，我们给内存进行编号，这个编号就是地址，在c语言中给这个地址起了个名字。是的，亲爱的读者你肯定发现了，&a、p和pc输出的地址是一样的,但&a+1与p+1输出的地址是一样的00EFF940，一次都跳过了4字节，而pc+1输出的却是00EFF93D，一次只跳过一个字节。但是硬件与硬件之间是相互独立的，这该如何实现数据传输呢？”答案当然是否定的。
命令执行漏洞（二）
XLbb的博客
05-15 900
POST方法，S2-045-bypass-2漏洞存在！,程序更改为S2-045-bypass-2漏洞测试模式, 响应码: 200。POST方法，S2-046-bypass漏洞存在！POST方法，S2-045-bypass漏洞存在！POST方法，S2-046-1漏洞存在！POST方法，S2-046-2漏洞存在！POST方法，S2-046-3漏洞存在！POST方法，S2-045-1漏洞存在！POST方法，S2-045-3漏洞存在！POST方法，S2-045-2漏洞存在！POST方法，S2-045-4漏洞存在！
day2txt_excel/vba读通达信日线_通达信_源码
01-29
day2txt_excel/vba是一个用于读取通达信日线数据的工具，可以帮助用户将通达信的日线数据转换成Excel或者VBA可以处理的格式。这个工具可以帮助用户快速、方便地处理大量的通达信日线数据，提高工作效率。 用户可以...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值