【Java】多线程编程（一）

最新推荐文章于 2024-06-25 23:19:15 发布
最新推荐文章于 2024-06-25 23:19:15 发布
阅读量961 收藏 1
点赞数 1
分类专栏： Java小叙 文章标签： java android jvm
// by Frms https://blog.csdn.net/qq_39751227?type=blog
本文链接：https://blog.csdn.net/qq_39751227/article/details/125948575
版权
本文详细探讨了多线程的必要性，展示了创建线程的多种方法，包括继承Thread、实现Runnable和Callable接口。还解析了线程状态、中断处理和同步机制，以及内存模型与并发特性，如原子性、可见性和volatile的用法。
摘要由CSDN通过智能技术生成

目录


Kotlin版本将会发布在【安卓小叙专栏】内。

线程基础

为何要使用多线程？

  • 多线程可以减少程序响应时间。如果某操作很耗时，可以再“后台（其他线程）”执行这个操作，而不至于让程序无法响应。
  • 与进程相比，线程创建和切换开销更小，多线程在数据共享方面效率很高。
  • 多线程有利于提高CPU使用效率。
  • 简化程序结构，便于维护。

创建线程几个方法

继承Thread，重写run方法

  Thread本身也是实现Runnable接口的一个实例。这样，只需要定义Thread的子类，重写run方法以执行需要的任务，然后实例化子类，就可以启用线程。

public class Main
{

	public static void main(String[] args)
	{
		new Main().new MyThread().start();
		// new (new Main().MyThread());
		// new (new Main().MyThread)();
	}
	
	public class MyThread extends Thread
	{
		@Override
		public void run() {
			super.run();
			System.out.println("Frank Miles");
		}
	}
}

实现Runnable接口，并实现run接口

 有两种，一是匿名接口，而是自定义类实现runnable接口。
匿名接口：

	public static void main(String[] args)
	{
		new Thread(new Runnable() {
			@Override
			public void run() {
				// TODO
			}
		}).start();
	}

当然，在jdk1.8或更高版本，也有简便写法：

new Thread(() -> {
	// TODO
}).start();

自定义类实现接口，一般在本类实现接口：

public class Main implements Runnable
{
	public static void main(String[] args)
	{
		Main main = new Main();
		main.runBody();
	}

	public void runBody()
	{
		new Thread(this).start();
	}
	
	@Override
	public void run() { }
}

也可以而外定义，这些语法技巧，这里不再大篇幅介绍了，读者可自行实践。

实现Callable接口，重新call方法

 Callable接口严格说是Executor框架中的功能类，与Runnable功能类似，但有更加强大的功能。比如：

  • Callable在任务接受后，提供一个返回值，Runnable则无此功能。
  • Callable的call方法可以抛出异常，而Runnable的run方法不能抛出异常。
  • Callable运行后可以拿到Future对象;Future对象表示异步操作的结果，提供了检查操作是否完成的方法。可以使用Future对象来监听目标线程调用call方法情况。但调用Future的get方法获取结果时，当前线程会被阻塞，直到目标线程call方法返回结果。

import static java.lang.System.*;


public class Main
{

	public static void main(String[] args)
	{
		Main main = new Main();
		main.runBody();
	}

	public void runBody()
	{
		MyCallable myCallable = new MyCallable();
		ExecutorService service = Executors.newSingleThreadExecutor();
		Future<String> future = service.submit(myCallable);
		try {
			out.println(future.get());
		} catch (InterruptedException | ExecutionException e) {
			e.printStackTrace();
		}
	}
	
	public class MyCallable implements Callable<String>
	{
		@Override
		public String call() throws Exception {
			return "你好，Frank Miles!";
		}
	}
}

 这里我们暂且不表newSingleThreadExecutor作用，只是宏观了解。

小结

 一般推荐实现runnbale接口，一个类应该在需要加强或修改时才会被继承，没有使用Thread其他重写方法的需求，就没有必要重写Thread方法。 ——《设计模式》

线程的状态

 java线程状态在运行的生命周期可能会处于一下6中状态之一。

  • New 新创建状态。线程被创建，还没有调用start()，还有基础工作要做的状态。
  • Runnable 可运行状态。一旦调用start()，就处于此状态。这个状态的线程，可能正在运行，也可能没有，这取决于操作系统给线程提供的运行时间。
  • Blocked 阻塞状态。表示线程被锁阻塞，暂时不活动。
  • Waiting 等待状态。暂不活动，不运行任何代码，直到线程调度器重新激活它。
  • Time waiting 超时等待，区别于 Waiting，可以在指定时间自行返回。
  • Terminated 终止状态。线程执行完毕，一是代码执行结束，二是异常没有捕获，强行终止。

 线程创建后（New ），start()调用开始，进入 Runnable 。之后操作如图示：

线程中断的理解

 一个线程在运行，可以调用stop()方法中断线程，但这个方法已经被废弃了。现在推荐使用interrupt()请求终止线程。
 当一个线程调用此方法时，线程中断标志位会设置为true。线程会不时检测这个中断标志位，以判断线程是否应该中断，要想知道线程是否被置位，可以调用Thread.currentThread().isInterrupted()，如下所示：

while (Thread.currentThread().isInterrupted()) {
	// TODO
}

 也可以调用Thread.interrupted()对中断标志位进行复位。但若一个线程被阻塞，就无法检测中断状态。
 如果一个线程处于阻塞状态，那么线程在检测中断标志位的时候若为true，会在阻塞方法出抛出InterruptedException，并且在抛出前恢复中断标志位为false。
注意，interrupt()只是请求终止，是否终止，需要线程自行决定。

中断处理方式

如果你不知道如何处理，这里以sleep作为阻塞条件，介绍两种处理方式。
一种是，在catch语句中，重新设置中断标志位为true，让外界通过Thread.currentThread().isInterrupted()决定是终止线程还是继续：

try {
	Thread.sleep(100);
} catch (InterruptedException e) {
	Thread.currentThread().interrupt();
}

 更好的做法是直接抛出这个问题，不做处理，留给调用的人处理（嗯??）

public void runBody() throws InterruptedException {
	Thread.sleep(100);
}

安全地终止线程

 调用interupted终止线程：

public class Main
{
	public static void main(String[] args) throws InterruptedException {
		Main main = new Main();
		main.runBody();
	}

	private int counter = 0;

	public void runBody() throws InterruptedException {
		Thread thread = new Thread(() -> {
			while (!Thread.currentThread().isInterrupted())
			{
				counter++;
				out.println(counter);
			}
			out.println("stop");
		});

		thread.start();
		// 留时间来感知结束
		TimeUnit.MICROSECONDS.sleep(100);
		thread.interrupt();
	}
}

 也可以使用volatile boolean来自主控制是否需要终止线程。


public class Main
{
	public static void main(String[] args) throws InterruptedException {
		Main main = new Main();
		main.runBody();
	}

	private volatile boolean running = true;

	private int counter = 0;

	public void runBody() throws InterruptedException {
		Thread thread = new Thread(() -> {
			while (running)
			{
				counter++;
				out.println(counter);
			}
			out.println("stop");
		});

		thread.start();
		TimeUnit.MICROSECONDS.sleep(100);
		cancel();
	}

	private void cancel()
	{
		running = false;
	}
}

volatile 后面会说，这里可以理解为，“涉及多个线程访问时，修改变量会让所有线程能尽快感知”，尽快，也就是说，不用volatile ，关系也不大，一样能终止，但终止时候，取决于这个线程什么时候去“检查这个变量”。

线程锁与同步

竞态条件

 两个或多个线程在对同一个变量进行读取和修改，这种行为可以称作竞态条件。
比如说买票问题：票数量固定，可以买票的地方很多，售票站就可称作线程，售票站需要查询和修改（购买）火车票，这样也是竞态条件。那么如何解决不同乘客买到同一座位的票的问题呢？解决办法是，当一个售票站需要购买票时，这个座位就被占用了（锁），其他售票站只能等待（线程阻塞）前一个售票站是否购买然后再做决定。

重入锁与条件对象

 重入锁ReentrantLock是java se 5.0引入，就是支持重进入的锁。它表示该锁能够支持一个线程对资源重复加锁。使用方法也简单：

public class Main
{
	public static void main(String[] args){
		Main main = new Main();
		main.runBody();
	}

	private final ReentrantLock mLock = new ReentrantLock();
	
	public void runBody() {
		Thread thread = new Thread(() -> {
			// 获得锁
			mLock.lock();
			// 解锁，如果有try-catch语句，应该在finally内加入以保证完整性。
			mLock.unlock();
		});

		thread.start();
	}
}

 发生异常，必须要释放锁，不然后面线程会永久阻塞▲

 锁的结构保证了访问或修改某值时，一次只能有一个线程，其他线程会被阻塞直到系统调度才运行。

 条件对象又称作条件变量，当一个线程获得锁后，却发现不满足条件，这时候就需要它。
 我见过很多教程，都是用转账来做例子，我认为这样还不够直观，使用转账例子，是为了更好说明多线程操作带来的死锁、金额总数变化的错误可能，但这里主要讲解条件对象，不会涉及上述知识，所以用类似申请权限的代码来做讲解分析，更容易理解，请先看代码：


public class Main
{
	public static void main(String[] args) {
		Main main = new Main();
		main.runBody();
	}

	private final ReentrantLock mLock = new ReentrantLock();
	private Condition mCondition;

	// 假设的条件
	private boolean needRunThread = true;

	public void runBody()
	{
		// 得到条件对象
		mCondition = mLock.newCondition();

		runFirst();
		getPermission();
	}

	private void runFirst()
	{
		final Thread thread = new Thread(() -> {
			// 获得锁
			mLock.lock();
			try {
				// 真正工作中，发起授权可能会有些额外代码，这里只做输出。
				out.println("正在发起授权");
				while (needRunThread)
				{
					out.println("无授权，进入条件阻塞状态");
					mCondition.await();
				}

				out.println("已获得授权");
			} catch (InterruptedException pException) {
				pException.printStackTrace();
			} finally {
				// 解锁
				mLock.unlock();
			}
		});

		thread.start();
	}

	private void getPermission()
	{
		final Thread thread = new Thread(() ->
		{
			mLock.lock();
			needRunThread = false;
			out.println("已允许给予授权");
			// 让所有因此条件进入阻塞的线程进入 可 运行状态。
			mCondition.signalAll();
			mLock.unlock();
		});

		thread.start();
	}
}

运行输出结果是：

正在发起授权
无授权，进入条件阻塞状态
已允许给予授权
已获得授权

 很明显，我们现在就能说明他们的执行过程：首先执行runFirst()，获得了锁，但条件并不满足，而且getPermission()也有同样的锁，上面也说了，同样的锁只能有一个线程，这就说明，runFirst()永远无法等待getPermission()的授权，因为getPermission()已经被锁阻塞了，这时候，就需要条件阻塞runFirst()线程（为什么不是结束runFirst()线程，等待授权后再运行？因为有的发起授权准备代码只能执行一次，而且也不容易在复杂场景实现）

 条件阻塞runFirst()线程方法很简单，调用await()就可以让runFirst进入阻塞状态，直到另一个线程调用signalAll()方法为止。

  • signalAll() 重新激活因为同一条件而等待的所有线程
  • signal() 重新激活因为同一条件而等待的随机的一条线程（有死锁的可能：激活的线程还不满足条件，也没激活其他线程）

  重新激活，不代表立即运行线程，而是只解除了等待线程的阻塞状态，以便这些线程通过竞争实现对象访问

同步方法块

 大多数情况下，使用ReentrantLock会显得过于臃肿，重复代码太多，所以在java 1.0开始，引入了嵌入到语言内部的同步和条件对象机制：java每一个类都有一个内部锁。
 比如说，若一个方法用synchronized 修饰，也就使用了方法所在的对象的锁来保护这个方法。比如：

private synchronized void body() {}

等价于

	private final ReentrantLock mLock = new ReentrantLock();
	
	private void body()
	{
		mLock.lock();
		try {
			// todo
		} finally {
			mLock.unlock();
		}
	}

 也可以对代码块来实现锁：

synchronized (this) {
	// todo		
}

 这里需要指定锁的对象，即回答谁的锁这个问题。这里用的是本类的锁。
另外，条件对象的方法，可以用Object自带的方法替代，替代规则如下：

ConditionObject方法
await()wait()
signal() / signalAll()notify() / notifyAll()

 现在，我们来替代上述代码，不使用ReentrantLock锁来实现：


public class Main
{
	public static void main(String[] args){
		Main main = new Main();
		main.runBody();
	}

	// 假设的条件
	private boolean needRunThread = true;

	public void runBody()
	{

		runFirst();
		getPermission();
	}

	private void runFirst()
	{
		final Thread thread = new Thread(() -> {
			try {
				synchronized (this)
				{
					// 真正工作中，发起授权可能会有些额外代码，这里只做输出。
					out.println("正在发起授权");
					while (needRunThread)
					{
						out.println("无授权，进入条件阻塞状态");
						wait();
					}

					out.println("已获得授权");
				}
			} catch (InterruptedException pException) {
				pException.printStackTrace();
			}
		});

		thread.start();
	}

	private void getPermission()
	{
		final Thread thread = new Thread(() ->
		{
			synchronized (this)
			{
				needRunThread = false;
				out.println("已允许给予授权");
				// 让所有因此条件进入阻塞的线程进入 可 运行状态。
				notifyAll();
			}
		});

		thread.start();
	}
}

小结

 同步代码是是非脆弱、难以纠错、维护性难的，通常只在简单线程使用。一般实现最好用java.util.concurrent包下的类。一般来说，只有在特别需要使用Lock/Condition结构时，才建议使用；只有在同步方法适合你的程序的时候，才建议使用同步代码块。

内存模型与并发特性

java内存模型

 Java堆内存用来存储对象实例，堆内存是被所有线程共享运行的内存区域，而局部变量、方法定义的参数则不会在线程共享。

 java内存定义了线程和主存之间的关系：线程间的共享变量储存在主存中，但线程都持有一个私有副本，当某线程副本被修改时，线程就会在合适的时机把数据提交到主存中，然后其他线程在合适时候从主存更新副本的值。

 需要注意的是，这只是一个抽象概念，并不真实存在，它是从缓存、写缓冲区、寄存区的角度来解释的。Java内存模型控制线程之间的通信，它决定一个线程对主存共享变量的写入何时对另一个线程可见。示意图可如下表示：


 线程A和线程B通信：A线程更新的变量数据提交给主存，然后B线程在合适时机读取主存变量并更新到副本中。

并发特性：原子性、可见性、重新排序和有序性

原子性

 对于基本数据的读取和赋值是原子操作，这些操作不能中断，要么执行，要么不执行。比如：

x = 3;

 特别的，以下操作就不是原子性：

y = x;
x++;

 y = x，执行了两个指令：1.读取x ，2. 把x的值赋值给y， 因此不具有原子性。
x++，自增操作不是原子性，因为它等价于 x = x +1，自然执行了三步：1. 读取 x, 2. 值x加1， 3. 把值赋值给x。所以也不具有原子性。

 java.util.concurrent.atomic包下很多类使用了机器级指令（不是锁）来保证给出的算法具有原子性，比如AtomicIntenger的方法，这些方法不多做介绍，请自查。值得注意的是，这些仅供开发并发工具的系统程序员使用，应用程序员不应该使用这些类。

可见性

 可见性，指的是线程之间的可见性，一个线程修改的状态对另一个线程是可见的，一个线程修改的结果，另一个线程可以立刻知晓。被volatile修饰的变量能保证立刻把值更新到主存中，所有其他线程可见，可读取新值。而未被volatile修饰的变量不一定会立刻更新到主存中去，自然其他线程读取的，可能是旧值。

重新排序

 编译器为或运行时环境为了优化程序而采取对指令进行重新排序执行的一种手段。分编译时环境产生的编译时排序和运行时环境产生的运行时排序。

有序性

 Java内存模型允许编译器和处理器对指令进行重新排序，重排序不会对单线程执行代码的正确性有任何影响，但会影响多线程并发执行的正确性。，除了volatile，也可以用上文提到的锁来保证有序性，也就是多线程操作指令由锁进行被动排序，实现先后访问，而不是交叉访问和修改值。

volatile用法

 volatile设计目的是在解决简单的读写一两个实例而提供同步访问的免锁机制。一个修饰了volatile的域，那么编译器和虚拟机就知道此域可能被另一个线程并发更新。

 共享变量被volatile修饰后，就会有两层含义。一、线程修改变量后，其他线程可立即感知。二、禁止使用指令进行重排序。

不保证原子性： volatile没有说所有牵涉到该变量的操作都具备原子性：比如自增就不属于。事实上，也确实没有原子性，只是保证数据修改时，其他线程可立即感知。

保证有序性： 因为volatile能禁止指令重排序。可以解释为，在 volatile变量之前的语句，不会 volatile之后执行。

volatile 可能优于 synchronized ，但优于不满足原子性，所以不能替代synchronized 。
 通常说，使用 volatile 必须具备以下条件：

  • 对变量的写操作不会依赖当前值。就是不能是自增、自减之类赋值依赖原有变量操作。

  • 该变量没有包含在具有其他变量的不变式中。也就是说，多个被volatile修饰的变量若一定满足某些不变公式（比如volatile a 一定 大于 volatile b）,由于多个线程的操作，这个不变式有被打破的风险。
    使用volatile一般有两种，其他具体用法可自行查阅资料。

  1. 状态标志，这个很常见，我们也用到过：

public class Main
{
	public static void main(String[] args) throws InterruptedException {
		Main main = new Main();
		main.runBody();
	}

	private volatile boolean running = true;

	private int counter = 0;

	public void runBody() throws InterruptedException {
		Thread thread = new Thread(() -> {
			while (running)
			{
				counter++;
				out.println(counter);
			}
			out.println("stop");
		});

		thread.start();
		TimeUnit.MICROSECONDS.sleep(100);
		cancel();
	}

	private void cancel()
	{
		running = false;
	}
}
  1. DCL （双重检查模式）
    双重检查模式，一般用在设计模式的单例模式。
public class Main
{
	// 这里牺牲一点性能保证正确性
	private volatile static Main instance = null;

	private Main() {}

	public static Main getInstance()
	{
		// 防止冗余同步
		if(instance == null)
		{
			synchronized (Main.class) {
				// 防止冗余实例化
				if(instance == null)
				{
					instance = new Main();
				}
			}
		}
		return instance;
	}
}

小结

 volatile 是一种简单而十分脆弱的同步机制，简单情况下确实优于锁的性能。在严格遵守使用规则确实能简化代码，但是因为volatile出错的代码比synchronized 更难发现和维护，也更容易出错，请酌情使用。

Frms
关注
专栏目录
《Kotin 极简教程》第15章 Kotlin 文件IO操作、正则表达式与多线程
AI天才研究院
07-24 8775
第15章 Kotlin 文件IO操作与多线程 《Kotlin极简教程》正式上架： 点击这里 &gt; 去京东商城购买阅读 点击这里 &gt; 去天猫商城购买阅读 非常感谢您亲爱的读者，大家请多支持！！！有任何问题，欢迎随时与我交流~ 我们在使用 Groovy 的文件 IO 操作的时候，感觉非常便利。同样的Kotlin也有好用的文件 IO 操作的...
Kotlin多线程
wozuishuai_的博客
02-22 2205
如果在操作对象之前，线程先声明：“这个对象是我的”，当另一个线程也想操作这个对象时，发现已经有人声明过了，那么它就等待，直到那个发布声明的线程又发了一个“这个对象不是我的了”的声明。当然，这两个声明其实起到了一个锁的作用，当声明“这个对象是我的”时，对象就被上了锁，当声明“这个对象不是我的了”时，对象的锁就被解开了。因为main线程创建了th线程，th线程又创建了th2线程。th线程调用join()方法等待th2线程时，main线程中断了th线程，因此th线程中的join()方法停止等待，执行完成。
Kotlin 多线程（1）
伯特立的专栏
12-31 4291
多线程
Kotlin 线程与并发：深入浅出
最新发布
u011464172的专栏
06-25 1118
线程是操作系统分配给程序的独立执行单元，可以理解为程序运行的最小单位。多个线程可以在同一个进程中并发执行，共享进程的内存空间和资源。本文深入探讨了 Kotlin 线程和并发编程的关键概念，包括线程创建、同步机制、异步处理以及代码示例。希望能够帮助读者更好地理解 Kotlin 线程和并发的基本原理，并能够在实际项目中应用这些知识。深入学习 Kotlin 协程，它提供了一种更加简洁、易于理解的异步编程方式。了解不同线程同步机制的特点，选择适合的同步方式来保证代码的线程安全。
Kotlin多线程编程
Lud的博客
07-28 8030
Kotlin中没有synchronized、volatile关键字。Kotlin的Any类似于java的Object，但是没有wait()、notify()和notifyAll()方法。 Kotlin通过封装java中的线程类，简化了我们的编码。同时我们可以使用一些特定的注解，使用java中的同步关键字等。 创建线程 在java中通常有两种方式来创建线程： 扩展Thread类或者进行实例化通过...
Java多线程编程核心技术_完整版_java_
09-30
本教程《Java多线程编程核心技术》将深入探讨这一主题。 一、线程的创建与启动 1. 继承Thread类：创建一个新的类，该类继承自Thread类，然后重写run()方法，最后创建该类的实例并调用start()方法启动线程。 2. 实现...
Java多线程编程总结
01-31
要认识多线程就要从操作系统的原理说起。以前古老的DOS操作系统（V6.22）是单任务的，还没有线程的概念，系统在每次只能做一件事情。比如你在copy东西的时候不能rename文件名。为了提高系统的利用效率，采用批处理来...
汪文君JAVA多线程编程实战（完整不加密）
01-19
《汪文君JAVA多线程编程实战》是一本专注于Java多线程编程的实战教程，由知名讲师汪文君倾力打造。这本书旨在帮助Java开发者深入理解和熟练掌握多线程编程技术，提升软件开发的效率和质量。在Java平台中，多线程是...
JAVA多线程编程技术PDF
08-28
这份“JAVA多线程编程技术PDF”是学习和掌握这一领域的经典资料，涵盖了多线程的全部知识点。 首先，多线程的核心概念包括线程的创建与启动。在Java中，可以通过实现Runnable接口或继承Thread类来创建线程。创建后...
Java多线程编程实战指南(核心篇)
07-17
Java多线程编程实战指南(核心篇) 高清pdf带目录 随着现代处理器的生产工艺从提升处理器主频频率转向多核化，即在一块芯片上集成多个处理器内核（Core），多核处理器（Multicore Processor）离我们越来越近了――如今...
Kotlin - 线程 Thread
HugMua的博客
07-10 2930
【代码】kotlin - 线程 Thread。
kotlin 多线程 android,Kotlin 协程和 Android SQLite API 中的线程模型
weixin_35719260的博客
05-25 269
image从 Room 2.1 版本之后，开发者们可以通过定义 suspend DAO 函数来使用 Kotlin 协程了。协程在处理异步操作时表现得异常优秀，它可以让您用顺序自然的代码处理诸如操作数据库一类的耗时操作，而不再需要专门在线程之间来回切换任务、处理结果或错误了。Room 支持协程后，可以在数据库操作中使用由并发作用域、生命周期、嵌套所带来的一些便利。在我们为 Room 添加协程的支持期...
Android开发多线程kotlin实现
weixin_42415553的博客
04-19 1004
最近论文的事情也整完了，想起之前项目中有遗留的问题，解决一下。 问题之一是多线程问题，项目比较小，用到多线程的地方不多。但是这里还是写一下。话不多说先上代码。 package com.ldx.mutiplethread import android.annotation.SuppressLint import androidx.appcompat.app.AppCompatActivity import android.os.Bundle import android.os.Handler import
Kotlin：该如何实现多线程同步？
Gaga246的博客
01-09 1248
1.1 协程是什么1.2 什么是Job 、Deferred 、协程作用域1.3 Kotlin协程的基础用法。
Kotlin(四)掌握基础知识：线程（Thread.kt）详解
yi_master的博客
01-13 4092
Kotlin(一)掌握基础知识：数据、集合、库函数 Kotlin(二)掌握基础知识：字符串和异常处理 Kotlin(三)掌握基础知识：类   线程是每一种语音不可能绕开的知识点，也是开发过程中肯定会遇见的，这章我们就来仔细看下Kotlin中如何使用线程，我们仔细看下Thread.kt文件的实现 package kotlin.concurrent public fun thread( st...
Kotlin线程的简单使用
cf8833的博客
10-08 3527
package com.example.admin.zkotlin import android.support.v7.app.AppCompatActivity import android.os.Bundle import android.util.Log import kotlinx.android.synthetic.main.activity_photo.* class Main...
Android中的多线程及AsyncTask的引入
weixin_43372114的博客
05-23 258
一、Android多线程的介绍        本质上来说，多线程的定义都是一样的，软件或硬件上并发地执行多条指令，将CPU的时间片按照调度算法，分配给各个线程，实际上是分时执行的，只是这个切换的时间很短，用户感觉的时候是同时而已。        Android...
kotlin的多线程编程
qq_44016573的博客
11-30 1344
如何启动这个线程？我们创建的myThread是MyThread实例，它是一个实现了Runnable接口的对象，所以我们可以直接把他传入Thread的构造函数中。接着我们再调用Thread的start方法，run方法中的内容就开始在子线程中运行了。
Kotlin - 线程
⚡
12-14 219
▷ 线程 import java.lang.Thread val th1 = Thread { for(i in 1..100){ println("show"); Thread.sleep(500) } } th1.start() Thread { for(i in 1..100){ println("show"...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值