Darren Yuen

suspend fun main() {  	withContext(Dispatchers.IO) {  		val result = async { getResult() }.await()  		println("result=$result")  	}  }    suspend fun getResult() = suspendCoroutine<Boolean> {  	val callback = object : Callback {  		override fun onSuccess() {  			it.resume(true)  		}  	  		override fun onFail() {  			it.resumeWithException(Exception("fail"))  		}  	  		override fun onCancel() {  			it.resume(false)  		}  	}  	handleCallback(callback)  }    fun handleCallback(callback: Callback) {  	callback.onFail()  }    interface Callback {  	fun onSuccess()  	fun onFail()  	fun onCancel()  }

// 自定义的可取消挂起函数  suspend fun customCancelableOperation(): String {  	return suspendCancellableCoroutine { continuation ->  		val job = GlobalScope.launch {  			try {  				// 模拟异步操作  				delay(1000)  				// 如果操作成功，恢复挂起操作并传递结果  				continuation.resume("Operation completed successfully")  			} catch (e: CancellationException) {  				// 如果操作被取消，处理取消操作  				continuation.resumeWithException(e)  			} catch (e: Exception) {  				// 如果操作失败，传递异常  				continuation.resumeWithException(e)  			}  		}  		  		// 当外部协程取消时，取消内部协程  		continuation.invokeOnCancellation {  		job.cancel()  		}  	}  }    fun main() = runBlocking {  	val job = launch {  		val result = customCancelableOperation()  		println(result)  	}  	  	delay(500) // 等待一段时间  	job.cancel() // 取消外部协程  	job.join()  }

fun main() = runBlocking {  	val exceptionHandler = CoroutineExceptionHandler { _, exception ->  		println("Caught exception: $exception")  	}  	  	val job = GlobalScope.launch(exceptionHandler) {  		println(data)  	}  	  	job.join()  }

fun <T> Continuation<T>.safeResume(value: T) {  	if (this is CancellableContinuation) {  		if (isActive) {  			resume(value)  		} else {  			CapaLog.d("Continuation", "continuation is not active")  		}  	} else throw Exception("Must use suspendCancellableCoroutine instead of suspendCoroutine")  }

/**  * Handle system messages here.  */  public void dispatchMessage(@NonNull Message msg) {  	if (msg.callback != null) {  		handleCallback(msg);  	} else {  		if (mCallback != null) {  			if (mCallback.handleMessage(msg)) {  				return;  			}  		}  		handleMessage(msg);  	}  }

boolean enqueueMessage(Message msg, long when) {  	if (msg.target == null) {  		throw new IllegalArgumentException("Message must have a target.");  	}  	// 因为可能在任意对象操作入队，而只会在looper所绑定的线程出队，所以这里加对象锁，保证入队出队操作是线程安全的	synchronized (this) {  		if (msg.isInUse()) {  			throw new IllegalStateException(msg + " This message is already in use.");  		}  		  		if (mQuitting) {  			IllegalStateException e = new IllegalStateException(  			msg.target + " sending message to a Handler on a dead thread");  			Log.w(TAG, e.getMessage(), e);  			msg.recycle();  			return false;  		}  		  		msg.markInUse();  		msg.when = when;  		Message p = mMessages;  		boolean needWake;  		if (p == null || when == 0 || when < p.when) {  			// New head, wake up the event queue if blocked.			// 当前队列为空  			msg.next = p;  			mMessages = msg;  			needWake = mBlocked;		} else {  			// Inserted within the middle of the queue. Usually we don't have to wake  			// up the event queue unless there is a barrier at the head of the queue  			// and the message is the earliest asynchronous message in the queue.  			needWake = mBlocked && p.target == null && msg.isAsynchronous();  			Message prev; 			// 按调度时间调整队列位置 			for (;;) {  				prev = p;  				p = p.next;  				if (p == null || when < p.when) {  					break;  				}  				if (needWake && p.isAsynchronous()) {  					needWake = false;  				}  			}  			msg.next = p; // invariant: p == prev.next  			prev.next = msg;  		}  			  		// We can assume mPtr != 0 because mQuitting is false.  		if (needWake) {  			nativeWake(mPtr);  		}  	}  	return true;  }

Message next() {  	// Return here if the message loop has already quit and been disposed.  	// This can happen if the application tries to restart a looper after quit  	// which is not supported.  	final long ptr = mPtr;  	if (ptr == 0) {  		return null;  	}  	  	int pendingIdleHandlerCount = -1; // -1 only during first iteration  	int nextPollTimeoutMillis = 0;  	for (;;) {  		if (nextPollTimeoutMillis != 0) {  		Binder.flushPendingCommands();  	}  	  	nativePollOnce(ptr, nextPollTimeoutMillis);  // 用来检查消息队列中是否有新的消息要处理，当队列为空时，`nativePollOnce` 会使线程等待直到：1. 有新消息到达。2. 被唤醒去处理其他任务（例如，定时事件、输入事件等）。3. 明确使用 `wakeUp()` 方法唤醒。	  	synchronized (this) {  		// Try to retrieve the next message. Return if found.  		final long now = SystemClock.uptimeMillis();  		Message prevMsg = null;  		Message msg = mMessages;  		if (msg != null && msg.target == null) {  			// Stalled by a barrier. Find the next asynchronous message in the queue.  			do {  				prevMsg = msg;  				msg = msg.next;  			} while (msg != null && !msg.isAsynchronous());  		}  		if (msg != null) {  			if (now < msg.when) {  				// Next message is not ready. Set a timeout to wake up when it is ready.  				nextPollTimeoutMillis = (int) Math.min(msg.when - now, Integer.MAX_VALUE);  			} else {  				// Got a message.  				mBlocked = false;  				if (prevMsg != null) {  					prevMsg.next = msg.next;  				} else {  					mMessages = msg.next;  				}  				msg.next = null;  				if (DEBUG) Log.v(TAG, "Returning message: " + msg);  				msg.markInUse();  				return msg;  			}  		} else {  			// No more messages.  			nextPollTimeoutMillis = -1;  		}  		  		// Process the quit message now that all pending messages have been handled.  		if (mQuitting) {  			dispose();  			return null;  		}  		  		// If first time idle, then get the number of idlers to run.  		// Idle handles only run if the queue is empty or if the first message  		// in the queue (possibly a barrier) is due to be handled in the future.  		if (pendingIdleHandlerCount < 0  			&& (mMessages == null || now < mMessages.when)) {  			pendingIdleHandlerCount = mIdleHandlers.size();  		}  		if (pendingIdleHandlerCount <= 0) {  			// No idle handlers to run. Loop and wait some more.  			mBlocked = true;  // 没有消息，休眠			continue;  		}  		  		if (mPendingIdleHandlers == null) {  			mPendingIdleHandlers = new IdleHandler[Math.max(pendingIdleHandlerCount, 4)];  		}  		mPendingIdleHandlers = mIdleHandlers.toArray(mPendingIdleHandlers);  		}  		  		// Run the idle handlers.  		// We only ever reach this code block during the first iteration.  		for (int i = 0; i < pendingIdleHandlerCount; i++) {  			final IdleHandler idler = mPendingIdleHandlers[i];  			mPendingIdleHandlers[i] = null; // release the reference to the handler  			  			boolean keep = false;  			try {  			keep = idler.queueIdle();  			} catch (Throwable t) {  			Log.wtf(TAG, "IdleHandler threw exception", t);  			}  			  			if (!keep) {  			synchronized (this) {  			mIdleHandlers.remove(idler);  			}  		}  		}  		  		// Reset the idle handler count to 0 so we do not run them again.  		pendingIdleHandlerCount = 0;  		  		// While calling an idle handler, a new message could have been delivered  		// so go back and look again for a pending message without waiting.  		nextPollTimeoutMillis = 0;  	}  }

private static boolean loopOnce(final Looper me,  final long ident, final int thresholdOverride) {  	Message msg = me.mQueue.next(); // might block  	if (msg == null) {  		// No message indicates that the message queue is quitting.  		return false;  	}    	// This must be in a local variable, in case a UI event sets the logger  	final Printer logging = me.mLogging;  	if (logging != null) {  		logging.println(">>>>> Dispatching to " + msg.target + " "  		+ msg.callback + ": " + msg.what);  	}  	// Make sure the observer won't change while processing a transaction.  	final Observer observer = sObserver;  	  	final long traceTag = me.mTraceTag;  	long slowDispatchThresholdMs = me.mSlowDispatchThresholdMs;  	long slowDeliveryThresholdMs = me.mSlowDeliveryThresholdMs;  	if (thresholdOverride > 0) {  		slowDispatchThresholdMs = thresholdOverride;  		slowDeliveryThresholdMs = thresholdOverride;  	}  	final boolean logSlowDelivery = (slowDeliveryThresholdMs > 0) && (msg.when > 0);  	final boolean logSlowDispatch = (slowDispatchThresholdMs > 0);  	  	final boolean needStartTime = logSlowDelivery || logSlowDispatch;  	final boolean needEndTime = logSlowDispatch;  		  	if (traceTag != 0 && Trace.isTagEnabled(traceTag)) {  		Trace.traceBegin(traceTag, msg.target.getTraceName(msg));  	}  	  	final long dispatchStart = needStartTime ? SystemClock.uptimeMillis() : 0;  	final long dispatchEnd;  	Object token = null;  	if (observer != null) {  		token = observer.messageDispatchStarting();  	}  	long origWorkSource = ThreadLocalWorkSource.setUid(msg.workSourceUid);  	try {  		msg.target.dispatchMessage(msg);  		if (observer != null) {  			observer.messageDispatched(token, msg);  		}  		dispatchEnd = needEndTime ? SystemClock.uptimeMillis() : 0;  	} catch (Exception exception) {  		if (observer != null) {  			observer.dispatchingThrewException(token, msg, exception);  		}  		throw exception;  	} finally {  		ThreadLocalWorkSource.restore(origWorkSource);  		if (traceTag != 0) {  			Trace.traceEnd(traceTag);  		}  	}  	if (logSlowDelivery) {  		if (me.mSlowDeliveryDetected) {  			if ((dispatchStart - msg.when) <= 10) {  				Slog.w(TAG, "Drained");  				me.mSlowDeliveryDetected = false;  			}  		} else {  			if (showSlowLog(slowDeliveryThresholdMs, msg.when, dispatchStart, "delivery",  			msg)) {  				// Once we write a slow delivery log, suppress until the queue drains.  				me.mSlowDeliveryDetected = true;  			}  		}  	}  	if (logSlowDispatch) {  		showSlowLog(slowDispatchThresholdMs, dispatchStart, dispatchEnd, "dispatch", msg);  	}  	  	if (logging != null) {  		logging.println("<<<<< Finished to " + msg.target + " " + msg.callback);  	}  	  	// Make sure that during the course of dispatching the  	// identity of the thread wasn't corrupted.  	final long newIdent = Binder.clearCallingIdentity();  	if (ident != newIdent) {  		Log.wtf(TAG, "Thread identity changed from 0x"  		+ Long.toHexString(ident) + " to 0x"  		+ Long.toHexString(newIdent) + " while dispatching to "  		+ msg.target.getClass().getName() + " "  		+ msg.callback + " what=" + msg.what);  	}  	  	msg.recycleUnchecked();  	  	return true;  }    /**  * Run the message queue in this thread. Be sure to call  * {@link #quit()} to end the loop.  */  @SuppressWarnings("AndroidFrameworkBinderIdentity")  public static void loop() {  	final Looper me = myLooper();  	if (me == null) {  		throw new RuntimeException("No Looper; Looper.prepare() wasn't called on this thread.");  	}  	if (me.mInLoop) {  		Slog.w(TAG, "Loop again would have the queued messages be executed"  		+ " before this one completed.");  	}  	  	me.mInLoop = true;  	  	// Make sure the identity of this thread is that of the local process,  	// and keep track of what that identity token actually is.  	Binder.clearCallingIdentity();  	final long ident = Binder.clearCallingIdentity();  	  	// Allow overriding a threshold with a system prop. e.g.  	// adb shell 'setprop log.looper.1000.main.slow 1 && stop && start'  	final int thresholdOverride =  	SystemProperties.getInt("log.looper."  	+ Process.myUid() + "."  	+ Thread.currentThread().getName()  	+ ".slow", 0);  	  	me.mSlowDeliveryDetected = false;  	  	for (;;) {  		if (!loopOnce(me, ident, thresholdOverride)) {  			return;  		}  	}  }

public View inflate(XmlPullParser parser, @Nullable ViewGroup root, boolean attachToRoot) {  	synchronized (mConstructorArgs) {  	View result = root;  	  	try {  		advanceToRootNode(parser);  		final String name = parser.getName();  		  		if (TAG_MERGE.equals(name)) {		// merge标签处理  			if (root == null || !attachToRoot) {  				throw new InflateException("<merge /> can be used only with a valid "  			+ "ViewGroup root and attachToRoot=true");  			}  		  			rInflate(parser, root, inflaterContext, attrs, false);  		} else {  			// Temp is the root view that was found in the xml  			final View temp = createViewFromTag(root, name, inflaterContext, attrs);  			  			ViewGroup.LayoutParams params = null;  			  			if (root != null) {  				// Create layout params that match root, if supplied  				params = root.generateLayoutParams(attrs);  				if (!attachToRoot) {  					// Set the layout params for temp if we are not  					// attaching. (If we are, we use addView, below)  					temp.setLayoutParams(params);  				}			} 			  			// Inflate all children under temp against its context.  			rInflateChildren(parser, temp, attrs, true);  			  			// We are supposed to attach all the views we found (int temp)  			// to root. Do that now.  			if (root != null && attachToRoot) {  				root.addView(temp, params);  			}  			  			// Decide whether to return the root that was passed in or the  			// top view found in xml.  			if (root == null || !attachToRoot) {  				result = temp;  			}  		}  	  	} catch (XmlPullParserException e) {  	} catch (Exception e) {  	} finally {  		// Don't retain static reference on context.  			}  	  	return result;  	}  }

class Box<T>(val value: T)  // T 的默认上界是 Any?

class Box<T : Any>(val value: T)  // T 的上界是 Any，所以 T 不能是 null

class Box<T>(val value: T)  // T 是一个泛型类型参数

class Box<T : Number>(val value: T)  // T 的上界是 Number，所以只能接受数字类型

fun printValue(value: Any) {  // 只接受非空的任何值	println(value)}fun printValue(value: Any?) {  // 可以接受任何值，包括 null    println(value)}

fun <T> isString(value: T): Boolean {   return value is String  // 会出现类型擦除的问题，此处 is String 仍然会编译通过但有警告} fun isString(value: Any): Boolean {   return value is String  // 不会被类型擦除，运行时仍然有效}

class Container<T>(val content: T) {	fun getContent(): T = content}fun <T> createContainer(item: T): Container<T> {	return Container(item)}

class Box<T>(val value: T)  // T 的隐式上界是 Any?

class Box<T : Number>(val value: T)  // T 的上界是 Number，因此只能接受 Number 的子类型

fun <T> ensureAllNonNull(vararg args: T) where T : Any, T : Comparable<T> {    for (arg in args) {        checkNotNull(arg)        println(arg)    }}

interface Source<out T> {    fun nextT(): T}fun demo(source: Source<String>) {    val anySource: Source<Any> = source // 协变，String 是 Any 的子类型，所以 Source<String> 可以赋值给 Source<Any>}

interface Consumer<in T> {    fun consume(item: T)}fun demo(consumer: Consumer<Number>) {    val intConsumer: Consumer<Int> = consumer // 逆变，Int 是 Number 的子类型，所以 Consumer<Number> 可以赋值给 Consumer<Int>}

// 定义一个具有上界的泛型类class Box<T : Number>(val value: T)fun <T : Number> sum(value1: T, value2: T): Double {    return value1.toDouble() + value2.toDouble()}// 定义一个协变接口interface Source<out T> {    fun nextT(): T}// 定义一个逆变接口interface Consumer<in T> {    fun consume(item: T)}fun main() {    // 使用具有上界的泛型类    val intBox = Box(1)    val doubleBox = Box(1.0)    println(sum(1, 2))         // 输出: 3.0    println(sum(1.0, 2.0))     // 输出: 3.0    // 示例协变    val stringSource: Source<String> = object : Source<String> {        override fun nextT(): String {            return "Hello"        }    }    val anySource: Source<Any> = stringSource    println(anySource.nextT())  // 输出: Hello    // 示例逆变    val numberConsumer: Consumer<Number> = object : Consumer<Number> {        override fun consume(item: Number) {            println("Consumed $item")        }    }    val intConsumer: Consumer<Int> = numberConsumer    intConsumer.consume(10)  // 输出: Consumed 10}

val filePath = "dir/${System.currentTimeMillis()}.pb"  var outputStream: FileOutputStream? = nulltry {  	val demoParam = addressBookBuilder.build()  	FileUtils.createOrExistsFile(File(filePath))  	outputStream = FileOutputStream(filePath)  try {  	demoParam.writeTo(outputStream)  } catch (t: Throwable) {    }  } catch (t: Throwable) {   } finally {  	outputStream?.close()  }