2020/08/27 QQ1017871939 初识线程

最新推荐文章于 2024-07-29 18:00:00 发布
最新推荐文章于 2024-07-29 18:00:00 发布
阅读量649 收藏
点赞数
分类专栏： 线程 小白 自定义线程 文章标签： java 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ok1017871939/article/details/108268203
版权
小白 同时被 3 个专栏收录
13 篇文章 0 订阅
订阅专栏
线程
1 篇文章 0 订阅
订阅专栏
自定义线程
1 篇文章 0 订阅
订阅专栏

在这里插入图片描述

初始线程

在这里插入图片描述

package com.xiancheng.ch01;

public class ThreadTest01 {

	 public static void main(String[] args) throws InterruptedException {
		//获得当前线程
		Thread t1 = Thread.currentThread();
		System.out.println("Threadname："+t1.getName());
		//获得ID
		System.out.println("ThreadID："+t1.getId());
		//获取优先级
		System.out.println("Thread优先级："+t1.getPriority());
	
	    //Thread.sleep(1000);//参数的单位是毫秒
	 for (int i = 1; i <=10; i++) {
		System.out.println(i);
		 Thread.sleep(1000);
	}
	 System.out.println("我睡眠了");
	 }
}

方法不运用线程的时候，程序像一根筋一样的走

在这里插入图片描述

package com.xiancheng.ch01;
/*
 * 开发线程的一个类，首先要求继承java.lang.Threa
 * 重写其中的run()方法
 */
//方法不运用线程就会变成整体就变成单一线程，先执行方法，等方法执行完告诉mian.main才执行
public class ThreadTest7  {
	  public void run() {
		  for (int i = 1; i <=10; i++) {
			  //currentThread()当前线程
				System.out.println("run:"+i);
			
				try {
					Thread.sleep(500);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
	  }
	  public static void main(String[] args) throws InterruptedException {		  
		  ThreadTest7 tt2 =new ThreadTest7();
		  tt2.run(); 
		  for (int i = 1; i <=10; i++) {
				System.out.println("main"+i);
				try {
					Thread.sleep(500);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
		  
	}
}

方法运用线程的时候，嘿，好兄弟我们一起走

在这里插入图片描述

package com.xiancheng.ch01;
/*
 * 开发线程的一个类，首先要求继承java.lang.Threa
 * 重写其中的run()方法
 */
//运用了线程，main方法就可以和线程一起执行，不用等到线程执行完毕结束main方法才接下来运行
public class ThreadTest6 extends Thread {
	//父类没有抛异常，子类不能抛异常，这次只能捕获
	  @Override
	    public void run() {
		  for (int i = 1; i <=10; i++) {
				System.out.println(Thread.currentThread().getName()+":"+i);
			
				try {
					Thread.sleep(500);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
	  }
	  public static void main(String[] args) throws InterruptedException {		  
		  ThreadTest6 tt2 =new ThreadTest6();
		 //join合并得在start之后
		  tt2.start();
//		  new Thread(tt2).start();
//		  new Thread(tt2).start();
		  for (int i = 1; i <=10; i++) {
			  //当main方法读到这句话的时候，告诉tt2我们合并在一起
			  //这时候合并线程，将tt2线程合并到了main线程，变成了一个线程
//			    tt2.join();
				System.out.println("main"+i);
				try {
					Thread.sleep(500);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
		  
	}
}

可以看出main老板调用线程的时候我是执行我线程方法，main老板懒得理我完成怎样了。这也不难举个例子，比如你QQ开空间的时候加载空间里面的内容和你点QQ头像聊天，你聊天的时候非得等你空间加载完成告诉我空间加载完成了吗？没必要，你加载你的空间，我聊我的天。别耽误我们的时间，其实线程也不难看出是统筹简算的成果。

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

package com.xiancheng.ch01;

public class ThreadTest01 {

	 public static void main(String[] args) throws InterruptedException {
		//获得当前线程
		Thread t1 = Thread.currentThread();
		System.out.println("Threadname："+t1.getName());
		//获得ID
		System.out.println("ThreadID："+t1.getId());
		//获取优先级
		System.out.println("Thread优先级："+t1.getPriority());
	
	    //Thread.sleep(1000);//参数的单位是毫秒
	 for (int i = 1; i <=10; i++) {
		System.out.println(i);
		 Thread.sleep(1000);
	}
	 System.out.println("我睡眠了");
	 }
}

在这里插入图片描述

第一种继承Thread类

在这里插入图片描述

package com.xiancheng.ch01;
/*
 * 开发线程的一个类，首先要求继承java.lang.Threa
 * 重写其中的run()方法
 */
//运用了线程，main方法就可以和线程一起执行，不用等到线程执行完毕结束main方法才接下来运行
public class ThreadTest6 extends Thread {
	//父类没有抛异常，子类不能抛异常，这次只能捕获
	  @Override
	    public void run() {
		  for (int i = 1; i <=10; i++) {
			  //currentThread()当前线程
				System.out.println(Thread.currentThread().getName()+":"+i);
			
				try {
					Thread.sleep(500);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
	  }
	  public static void main(String[] args) throws InterruptedException {		  
		  ThreadTest6 tt2 =new ThreadTest6();
		  //如果你写成tt2.run()是启动线程执行run方法
		  //而不是启动线程，启动线程用tt2.start
		  tt2.start();
		  for (int i = 1; i <=10; i++) {
				System.out.println("main"+i);
				try {
					Thread.sleep(500);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
		  
	}
}

多次调用线程的方法一

在这里插入图片描述

多次调用线程的方法二

在这里插入图片描述

第二种 实现Runnable接口

在这里插入图片描述

package com.xiancheng.ch01;
/*
 * 线程的实现 方式二
 * 实现runnable接口，实现其中run（）方法
 * 如何启动这个线程？
 */
public class ThreadTest8 implements Runnable {
	@Override
	public void run() {
		 for (int i = 1; i <=10; i++) {
				System.out.println("run:"+i);
				 try {
					Thread.sleep(500);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
				
			}
	}

public static void main(String[] args) {
	 
	 ThreadTest8 tt3 =new ThreadTest8();
	 new Thread(tt3).start();
		for(int i=1;i<=10;i++) {
			
			System.out.println("main : "+i);
			
			try {
				Thread.sleep(500);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
}
}

Runable接口多次调用线程方法

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

拓展补充线程创建的另外两种方法

方法一：实现Callable接口

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

代码

package com.UserMangertest01;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

/*
 * JDK5.0新增的线程的实现方式：
 * 实现方式三：
 *  > 实现这个接口：Callable，实现call方法
 *  > 创建FutureTask实例，通过线程实现类构造完成的
 *  > 通过Thread类的实例来启动线程
 *  > 通过 task.get();获取返回值
 *  
 */
public class ThreadTest111 implements Callable {

	int sum =0;
	@Override
	public Object call() throws Exception {
		//完成1-100累加和
		for (int i = 1; i <=100; i++) {
			sum+=i;
			System.out.println("sum:"+sum);
		     Thread.sleep(20);
		}
		return sum;
	}
	public static void main(String[] args) throws InterruptedException, ExecutionException {
		
		ThreadTest111 tt1 =new ThreadTest111();
		//没有直接调用的方法，这里得先创建一个未来的任务
		FutureTask task =new FutureTask(tt1);
		//再去执行未来任务里面的内容
		new Thread(task).start();
		//不过能获取返回值
		Object str =task.get();
		System.out.println(str);
		//总结，我觉得Callable接口实现线程步骤挺复杂的，不过它有renturn返回值这一功能，怎么说有的也有失吧
	}

}

方法二 ：线程池方法

在这里插入图片描述

newFixedThreadPool() 创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。

在这里插入图片描述

代码

package com.UserMangertest01;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class ExcutorTest1 {
   public static void main(String[] args) {
	//线程池的演示
	  ExecutorService threadPool =  Executors.newFixedThreadPool(100);
	  //for循环是为了创造多对线程，轻松快速
      for (int i = 0; i < 30; i++) {
	  threadPool.execute(new MyThread101() );
      threadPool.execute(new MyThread102() );		
	}
	  
//      threadPool.execute(new MyThread101() );
//      threadPool.execute(new MyThread102() );
      //用完记得关闭线程池
      threadPool.shutdown();
   //总结，虽然线程池的名字很长，但是我感觉真的很好用
   }
}

class MyThread101 implements Runnable{

	@Override
	public void run() {
          for (int i = 0; i < 100; i++) {
			if(i%2==0) {
				System.out.println(Thread.currentThread().getName()+"---->"+i);
			try {
				Thread.sleep(20);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			}
		}		
	}
	
}

class MyThread102 implements Runnable{

	@Override
	public void run() {
          for (int i = 0; i < 100; i++) {
			if(i%2!=0) {
				System.out.println(Thread.currentThread().getName()+"---->"+i);
			try {
				Thread.sleep(20);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			}
		}		
	}
	
}

在这里插入图片描述

中断线程的操作

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

在这里插入图片描述

package com.xiancheng.ch01;
/*
 * 线程的实现 方式二
 * 实现runnable接口，实现其中run（）方法
 * 如何启动这个线程？
 */
public class ThreadTest8 implements Runnable {
	//每个线程都有flag，标志着中断位
	/*
	 * 因为服务或线程不能被立即停止，立即停止会使共享的数据结构不一致，相反，应该在停止前做一些清理工作，然后再结束。
	 * 所以说，不能你让我停我就停，我自己执行的任务，我比你更能清楚在停止前如何进行清理工作。
	 * 因此，最终的设计就变成了：线程main给tt3发interrupt信号，B收到信号后，自己决定先做些什么，然后再退出。
	 * 这是一种协作机制，需要tt3配合。
	 */
	private boolean flag; //默认为false没有定义的时候
	
	public boolean isFlag() {
		return flag;
	}

	public void setFlag(boolean flag) {
		this.flag = flag;
	}

	@Override
	public void run() {
		 for (int i = 1; i <=10; i++) {
				System.out.println("run:"+i);
				 try {
					Thread.sleep(500);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
				 if(flag) {
					 //tt3检查自己的interrupt状态为true，并自愿地退出线程，是Java中唯一的一个线程让另一个线程终止的方法！
					 return;
				 }
//				 if(i==5) {
//					 //当i==5的时候终止线程的演示 //不是最佳选择
//					 Thread.currentThread().interrupt();//java.lang.InterruptedException
//				 }
				
			}
	}

public static void main(String[] args) {
	 
	 ThreadTest8 tt3 =new ThreadTest8();
	 new Thread(tt3).start();

		for(int i=1;i<=10;i++) {
			
			System.out.println("main : "+i);
			
			try {
				Thread.sleep(500);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			if(i==5) {
				//如果main方法想让tt3这个线程结束，就把这个中断位flag设为true
				//终止tt3这个线程
				tt3.setFlag(true);
			}
		}
}
}

在这里插入图片描述

方法一

在这里插入图片描述

package com.xiancheng.ch01;

public class ThreadTest9 {

	 public static void main(String[] args) {
		 Nunoushu p1 =new Nunoushu();
		 Nunjishu p2 =new Nunjishu();
		 
		 p1.start();
		 
		 p2.start();
	}
}

class Nunoushu extends Thread {
	
	public void run() {
		for (int i = 1; i <= 100; i++) {
			if(i % 2 == 0) {
				System.out.println(this.getName()+" --> "+i);
			}
			try {
				sleep(1000);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
	}
}

class Nunjishu extends Thread {
	
	public void run() {
		for (int i = 1; i <= 100; i++) {
			if(i % 2 != 0) {
				System.out.println(this.getName()+" --> "+i);
			}
		  try {
			sleep(1000);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		}
	}
}

方法二（用匿名类）
在这里插入图片描述

package com.xiancheng.ch01;

public class ThreadTest10 {

	public static void main(String[] args) {
		
		//匿名类的奇数
		new Thread() {
			public void run() {
				for (int i = 1; i <= 100; i++) {
					if(i % 2 != 0) {
						System.out.println(this.getName()+" --> "+i);
					}
					try {
						sleep(1000);
					} catch (InterruptedException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
				}
			}
		}.start();
		
		//匿名类的偶数
		new Thread() {
			public void run() {
				for (int i = 1; i <= 100; i++) {
					if(i % 2 == 0) {
						System.out.println(this.getName()+" --> "+i);
					}
					try {
						sleep(1000);
					} catch (InterruptedException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
				}
			}
		}.start();
	}
}

有的人觉得输出名字很丑在控制台上 可以修改名字

方法一

在这里插入图片描述

方法二

在这里插入图片描述

方法三

调用父类String的方法

在这里插入图片描述

代码

package com.xiancheng.ch01;

public class ThreadTest9 {

	 public static void main(String[] args) {
		 Nunoushu p1 =new Nunoushu("偶数");
		 Nunjishu p2 =new Nunjishu("奇数");
		 p1.start();
//方法一	 
//		 p1.setName("偶数");
//		 p2.setName("奇数");
		 p2.start();
	}
}

class Nunoushu extends Thread {
	
//方法二  在每一个自己的类里面构造

	public Nunoushu(String name) {
		//方法三
		//因为父类中存在有
		//   public Thread(String name) 
		//可以重写父类的构造方法
		super(name);
	}
	

	public void run() {
		for (int i = 1; i <= 100; i++) {
			if(i % 2 == 0) {
				//当super父类的时候，所用的方法是父类，
				//父类里面有 public final synchronized void setName(String name) 
				System.out.println(this.getName()+" --> "+i);
			}
			try {
				sleep(1000);
			} catch (InterruptedException e) {
			
				e.printStackTrace();
			}
		}
	}
}

class Nunjishu extends Thread {
	
//方法三  继承父类的构造方法改写
	public Nunjishu(String name) {
		super(name);
	}

	public void run() {
		for (int i = 1; i <= 100; i++) {
			if(i % 2 != 0) {
				System.out.println(this.getName()+" --> "+i);
			}
		  try {
			sleep(1000);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		}
	}
}

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

package com.xiancheng.ch01;

public class ThreadTest9 {

	 public static void main(String[] args) {
		 Nunoushu p1 =new Nunoushu("偶数");
		 Nunjishu p2 =new Nunjishu("奇数");
		 p1.setPriority(Thread.MAX_PRIORITY);
		 p1.start();
		 System.out.println("-------------------->>>>> "+p1.isAlive());
	    	//设置优先级必须在启动前面，不能给负数或者给小于最小优先级  不然会报错。


		 p2.setPriority(Thread.MIN_PRIORITY);
		 p2.start();
		 
		 System.out.println("-------------------->>>>> "+p2.isAlive());
	}
}

class Nunoushu extends Thread {
	
	public Nunoushu(String name) {
		super(name);
	}
	

	public void run() {
		for (int i = 1; i <= 100; i++) {
			if(i % 2 == 0) {
				System.out.println(this.getName()+" --> "+i);
			}
			
		}
	}
	
}

class Nunjishu extends Thread {

	public Nunjishu(String name) {
		super(name);
	}

	public void run() {
		for (int i = 1; i <= 100; i++) {
			if(i % 2 != 0) {
				System.out.println(this.getName()+" --> "+i);
			}
		
		}
	}
}
五菱开发工程师
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
QT 初识线程(简单实现)
断点
11-25 2376
QT多线程专栏共有14篇文章，从初识线程到、QMutex锁、QSemaphore信号量、Emit、Sgnals、Slot主线程子线程互相传值同步变量、QWaitCondition、事件循环、QObjects、线程安全、线程同步、线程异步、QThreadPool线程池等线程操作进行了全面！深入！的研究和详细的说明
ch01 Python基本语法元素
qq_46173177的博客
08-20 205
第一章 Python基本语法元素 1.1 程序设计基本方法 根据执行方式不同，编程语言分为两类。 静态语言：使用编译执行的编程语言，如C/C++语言、Java语言。 编译器一次性生成目标代码，之后不再需要源代码。 脚本语言：使用解释执行的编程语言，如Python语言、JavaScript语言、PHP语言。 执行程序时需要源代码，运行时随翻译随执行。 IPO：程序的基本编写方法 I：Input输入；P：Process处理；O：Output输出。 1.2 Python开发环境 Python基本开发环境IDLE
【多线程】初识多线程
程序猿教你打篮球的博客
04-12 5075
本期主要讲解： 1.为什么要学习多线程? 2.进程的认识 2.1进程与线程的关系 2.2进程间如何通信? 3.计算机如何描述进程的? 3.1概述 3.2 PCB是如何描述进程的? 4.线程的调度 5.线程的缺点
java并发编程之初识线程
FOREVER_DO
08-07 759
java并发编程之初识线程说明线程生命周期线程创建线程间通信线程池生产者消费者实例 说明 操作系统运行一个程序就会创建一个进程，例如我们一个main函数程序启动了，就会创建一个java进程，然后有一个main主线程和其他线程（至少一个垃圾回收线程），这时我们如果想java做的任务更多时间更少就可以创建更多线程，这样能够最大化利用cpu,更快响应。 线程生命周期 线程创建 线程间通信 线程池 生产...
使用hutool工具判断字符串是否全部是字母(包括大小写)，java判断字符串是否全部是字母(包括大小写)
qq_43700885的博客
07-29 257
1.导入hutool的maven依赖。2.复制一下代码执行。
golang 接口
m0_70982551的博客
07-24 1032
接口定义了一组方法，这些方法没有具体的实现。接口类型的变量可以存储任何实现了这些方法的类型的值。// 更多方法...在Go语言中，接口值是指存储了实现某个接口的具体类型值的变量。接口值由两部分组成：1.动态类型：这是接口值当前存储的实际类型。2.动态值：这是实际存储的值，该值必须实现了接口中定义的所有方法。
java判断邮箱地址是否正确，使用hutool工具判断邮箱地址是否正确
qq_43700885的博客
07-29 107
1.导入hutool的maven依赖。2.直接复制一下代码运行。
Swagger使用Map接受参数时，页面如何显示具体参数及说
a1058926697的博客
07-26 560
后端使用Map接受参数，要求在swagger页面上显示具体的参数名称、类型及说明。当Map接受参数数量少时，可以使用Swagger自带的注解。自定义注解 @ApiGlobalModel。编写处理注解对应的插件。
26.jdk源码阅读之ConcurrentLinkedQueue
最新发布
前端、移动端、后端源码级底层原理分享
07-29 742
ConcurrentLinkedQueue 是 Java 中提供的一个基于无界非阻塞算法的线程安全队列。它是一个适用于高并发环境的队列实现，基于链表结构。
Java的@DateTimeFormat注解与@JsonFormat注解的使用对比
訾博（ZiBo）的博客
07-27 688
在Spring和Jackson框架中，日期和时间格式化是一个常见需求。注解主要用于Spring的表单绑定，而注解则用于Jackson的JSON序列化和反序列化。了解这两个注解的使用场景和方法，可以帮助开发者更高效地处理日期和时间。和是处理日期和时间格式化的两个重要注解。主要用于Spring MVC的请求参数绑定，而主要用于Jackson的JSON序列化和反序列化。了解它们的使用场景和功能，可以帮助开发者更高效地处理日期和时间格式化需求。通过本文的介绍，希望读者能够更清晰地理解和。
Java修炼 2024.7.26 0:24
2301_80011650的博客
07-26 440
问题：编写一个方法，找出一个数组中的众数（出现次数超过数组长度一半的元素）。例如，输入 [2, 2, 1, 1, 2]，输出 2。编写一个方法，找出一个整数数组中的第二大元素。例如，输入 [3, 5, 1, 8, 7]，输出 7。例如，输入 5，输出 5。问题：编写一个方法，将给定的字符串逆转。问题：使用数组实现栈，并提供基本操作（push、pop、peek、isEmpty）。问题：实现一个单向链表，并提供基本的操作（添加、删除、查找元素）。问题：编写一个方法来查找一个给定字符串的所有子串。
Java代码基础算法练习-数的特性-2024.07.25
Sakurapaid的博客
07-25 388
小A喜欢两种性质都成立的数字，小B喜欢至少符合一种性质的数字，小C喜欢不符合这两种性质的 数字。给出一个数字，请输出三个人是否喜欢这个数字。如果喜欢输出1，否则输出0，用空格分隔。输入数字 num，先定义三个整型代表三个人的喜欢与否，先默认设为 0。之后判断num对于性质1、2的条件，分别用 boolen 类型标识。对于每个整型进行判断，是否改为 1 代表喜欢。性质2：大于4且不大于12;
新建springboot项目找不到java版本8?
weixin_74009895的博客
07-28 138
新建springboot项目找不到java版本8?
SSM框架整合——常用方式整合SSM框架（三）Spring和MyBatis整合
PAP
07-26 202
SSM框架整合——常用方式整合SSM框架（三）Spring和MyBatis整合
高级java每日一道面试题-2024年7月29日-并发篇-什么时候用乐观锁,什么时候用悲观锁?
qq_43071699的博客
07-29 339
悲观锁适用于数据竞争激烈的场景，能够提供强一致性，但可能导致较多的线程等待。乐观锁适用于读多写少的场景，能够提供更高的并发性能，但可能需要多次尝试才能成功更新数据。
19.jdk源码阅读之FutureTask
前端、移动端、后端源码级底层原理分享
07-25 877
FutureTask 是 Java 并发包中的一个重要类，它实现了 RunnableFuture 接口，结合了 Future 和 Runnable 的特性。FutureTask 通常用于异步任务的执行和结果的获取。
c++ 智能指针shared_ptr与make_shared
Txwtech笛克特科
07-25 289
shared_ptr是C++11引入的一种智能指针，‌它允许多个shared_ptr实例共享同一个对象，‌通过引用计数来管理对象的生命周期。‌当最后一个持有对象的shared_ptr被销毁时，‌它会自动删除所指向的对象。‌这种智能指针主要用于解决资源管理问题，‌避免内存泄漏。make_shared是C++标准库中的一个函数，‌用于创建一个shared_ptr智能指针，‌它接受一个或多个参数来构造一个对象，‌并返回一个指向该对象的shared_ptr。类SerialModbus的成员指针。
Java —— 线程
JL_L666的博客
07-26 669
程序(program)：为完成特定的任务，选用某一种语言编写的，即指，静态对象。进程(process)：程序的一次执行过程，或是。程序是静态的、进程是。进程是调度和分配资源的最小单位。注意：不同的进程之间是不共享内存的、进程之间的数据交换和通信的成本很高。线程(thread)：进程可以进一步细化为线程，是运行中进程的一条或多条执行路径。线程调度策略单核CPU与多核CPU并行与并发上。
Unix/Linux下POSIX多线程编程详解与接口
本章节深入探讨Unix/Linux多线程编程，建立在前面的多线程编程基础知识之上，特别关注在这样的系统环境下如何利用POSIX标准进行开发。POSIX，全称可移植操作系统接口，是一个旨在确保软件跨多个UNIX系统平台可移植性...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值