Kotlin 是一种在 Java 虚拟机上运行的静态类型编程语言，Kotlin 可以编译成Java字节码，也可以编译成 JavaScript，可以完美运行在 Java 环境。
Kotlin 语言主要是具有以下特性：
1.语法简洁、高级
2.空指针安全
3.完全兼容Java：可Kotlin 和 Java 两种语言混合开发
4.函数式编程：扩展函数、支持Lambda表达式
5.类型推断：无需指明类型
6.强大的协程：处理线程问题
7.委托：延迟加载，提高加载速度
8.不可变数据
9.无需 findViewById获取控件：有些地方不推荐使用
Kotlin 可谓集大家之所长，极大提升了Android原生代码的开发效率，备受欢迎。
一、Kotlin 环境搭建
在创建项目工程的时候直接勾选 Include Kotlin support 选项，选择 Kotlin 语言即可。
如果是Java老项目，Android Studio 需要安装Kotlin插件，同时手动配置 gradle，配置如下：
在 app 模块的 gradle 下加入如下代码：
apply plugin: 'kotlin-android'
apply plugin: 'kotlin-android-extensions'
在 project 模块的 gradle 下加入如下代码
ext.kotlin_version = '1.4.21'
dependencies {
classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
}后文是 Kotlin 语言的具体介绍和使用，同时与 Java 语言进行对比，方便理解
二、对象
TestActivity.thisthis@TestActivity
三、类
TestActivity.classTestActivity::class.java
四、继承
public class TestActivity extends Activity {}（在 Kotlin 中被继承类必须被 open 关键字修饰）
class TestActivity : Activity() {}
五、变量
Bean bean= new Bean();var bean= Bean()六、常量
final String text = "1314520";val text = "1314520"
七、静态常量
public class TestActivity extends Activity {
static final String text = "1314520";
}const val text = "1314520"
class TestActivity : Activity() {
}
八、定义方法
public void dumpTest(String message) {
}（Unit 跟 void 一样效果）
fun dumpTest(message : String) : Unit {
}// 在 Kotlin 可以省略 Unit 这种返回值
fun dumpTest(message : String) {
}
九、重载方法
public class TestActivity extends Activity {
@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
}
}class TestActivity : Activity() {
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
}
}
十、基本数据类型
int i = 1;
long l = 2;
boolean b = true;
float f = 0;
double d = 0;
char c = 'A';
String s = "text";var i : Int = 1
var l : Long = 2
var b : Boolean = true
var f : Float = 0F
var d : Double = 0.0
var c : Char = 'A'
var s : String = "text"
// 更简洁点可以这样，自动推倒类型
var i = 1
var l = 2
var b = true
var f = 0F
var d = 0.0
var c = 'A'
var s = "text"
十一、比较类型
if ("1314520" instanceof String) {
}if ("1314520" is String) {
}
十二、转换符
int number = 100;
Log.d(TAG,String.format("数量有%d", number));var number = 100
Log.d(TAG,"数量有${number}")
// 换种简洁的写法
var number = 100
Log.d(TAG,"数量有$number")
// 如果不想字符串被转义可以使用\$
var number = 100
Log.d(TAG,"数量有\$number")
十三、字符串比较
String a1 = "123";
String a2 = "123";
if (a1.equals(a2)) {
}Kotlin 的写法（Kotlin 对字符串比较的写法进行优化了，其他类型对象对比还是要用 equals 方法）
var a1 = "123"
var a2 = "123"
if (a1 == a2) {
}
十四、数组
int[] array1 = {1, 2, 3};
float[] array2 = {1f, 2f, 3f};
String[] array3 = {"1", "2", "3"};val array1 = intArrayOf(1, 2, 3)
val array2 = floatArrayOf(1f, 2f, 3f)
val array3 = arrayListOf("1", "2", "3")
十五、循环
String[] list = {"1", "2", "3"};
for (int i = 0; i < list.length; i++) {
Log.d(TAG,list[i]);
}val list= arrayListOf("1", "2", "3")
for (i in list.indices) {
Log.d(TAG,list[i])
}
十六、索引循环
String[] list= {"1", "2", "3"};
for (int i = 1; i < list.length; i++) {
Log.d(TAG,list[i]);
}Kotlin 的写法（这种写法在 Kotlin 中称之为区间）
val list= arrayListOf("1", "2", "3")
for (i in IntRange(1, list.size - 1)) {
println(list[i])
}
// 换种更简洁的写法
val list= arrayListOf("1", "2", "3")
for (i in 1..list.size - 1) {
println(list[i])
}
// 编译器提示要我们换种写法
val list= arrayListOf("1", "2", "3")
for (i in 1 until list.size) {
println(list[i])
}
十七、高级循环
String[] list= {"1", "2", "3"};
for (String text : list) {
Log.d(TAG,text);
}val list= arrayListOf("1", "2", "3")
for (text in list) {
println(text)
}
十八、判断器
int count = 1;
switch (count) {
case 0:
Log.d(TAG,count);
break;
case 1:
case 2:
Log.d(TAG,count);
break;
default:
Log.d(TAG,count);
break;
}var count = 1
when (count) {
0 -> {
println(count)
}
in 1..2 -> {
println(count)
}
else -> {
println(count)
}
}
// 换种更简洁的写法
var count = 1
when (count) {
0 -> println(count)
in 1..2 -> println(count)
else -> println(count)
}
十九、构造函数
public class TestView extends View {
public TestView (Context context) {
this(context, null);
}
public TestView (Context context, @Nullable AttributeSet attrs) {
this(context, attrs, 0);
}
public TestView (Context context, @Nullable AttributeSet attrs, int defStyleAttr) {
super(context, attrs, defStyleAttr);
}
}class TestView : View {
constructor(context : Context) : this(context, null) {
}
constructor(context : Context, attrs : AttributeSet?) : this(context, attrs, 0) {
}
constructor(context : Context, attrs : AttributeSet?, defStyleAttr : Int) : super(context, attrs, defStyleAttr) {
}
}// 换种更简洁的写法
class TestView : View {
constructor(context : Context) : this(context, null)
constructor(context : Context, attrs : AttributeSet?) : this(context, attrs, 0)
constructor(context : Context, attrs : AttributeSet?, defStyleAttr : Int) : super(context, attrs, defStyleAttr)
}// 只有一种构造函数的还可以这样写
class TestView(context: Context?) : View(context) {
}
二十、类创建
public class Bean{
String name;
int age;
public Bean(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
Bean bean= new Bean("xiaoxiao", 90);
bean.setName("xiaoxiao");
bean.setAge(25);
Log.d(TAG,"name: " + bean.getName() + ", age: " + bean.getAge());Kotlin 的写法（如果不想暴露成员变量的set方法，可以将 var 改成 val )
class Bean{
var name : String? = null
get() = field
set(value) {field = value}
var age : Int = 0
get() = field
set(value) {field = value}
}// 换种更简洁的写法
class Bean(var name : String, var age : Int)
var bean= Beanb("xiaoxiao", 90)
bean.name = "xiaoxiao"
bean.age = 25
println("name: {$bean.name}, age: {$bean.age}")
二十一、私有化 set 方法
public class Bean{
String name;
int age;
public Bean(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
private void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
private void setAge(int age) {
this.age = age;
}
}Kotlin 的写法
class Bean{
var name : String? = null
private set
var age : Int = 0
private set
}
二十二、私有化 get 方法
public class Bean{
String name;
int age;
public Bean(String name, int age) {
this.name = name;
this.age = age;
}
private String getName() {
return name;
}
private void setName(String name) {
this.name = name;
}
private int getAge() {
return age;
}
private void setAge(int age) {
this.age = age;
}
}Kotlin 的写法
class Bean{
private var name : String? = null
private var age : Int = 0
}
二十三、枚举
enum Sex {
MAN(true), WOMAN(false);
Sex(boolean isMan) {}
}Kotlin 的写法
enum class Sex (var isMan: Boolean) {
MAN(true), WOMAN(false)
}
二十四、接口
public interface Callback {
void onSuccess();
void onFail();
}在Kotlin中，接口的方法可以有默认实现，这意味着它们不需要在接口的实现类中强制实现。然而，请注意，Kotlin的接口默认实现特性与Java 8中的默认方法有所不同，但它提供了类似的功能。
以下是一个Kotlin接口Callback的实现，其中onSuccess和onFail方法都包含了默认实现：
interface Callback {
fun onSuccess() {
// 默认实现，当调用者没有覆盖这个方法时，将执行这里的代码
println("Operation was successful.")
}
fun onFail() {
// 默认实现，当调用者没有覆盖这个方法时，将执行这里的代码
println("Operation failed.")
}
}
二十五、匿名内部类
new Callback() {
@Override
public void onSuccess() {
}
@Override
public void onFail() {
}
};object:Callback {
override fun onSuccess() {
}
override fun onFail() {
}
}
二十六、内部类
public class TestActivity extends Activity {
public class MyTask {
}
}class TestActivity : Activity() {
inner class MyTask {
}
}
二十七、内部类访问外部类同名变量
String name = "Zhangsan";
public class MyTask {
String name = "ZS";
public void show() {
System.out.println(name + "---" + MainActivity.this.name);
}
}var name = "Zhangsan"
inner class MyTask {
var name = "ZS"
fun show() {
println(name + "---" + this@MainActivity.name)
}
}
二十八、抽象类
public abstract class BaseActivity extends AppCompatActivity implements Runnable {
abstract void init();
}abstract class BaseActivity : AppCompatActivity(), Runnable {
abstract fun init()
}
二十九、静态变量和方法
public class ToastUtils {
public static Toast sToast;
public static void show() {
sToast.show();
}
}（在 Kotlin 将这种方式称之为伴生对象）
companion object ToastUtils {
var sToast : Toast? = null
fun show() {
sToast!!.show()
}
}
三十、可变参数
public int add(int... array) {
int count = 0;
for (int i : array) {
count += i;
}
return count;
}fun add(vararg array: Int) : Int {
var count = 0
//for (i in array) {
// count += i
//}
array.forEach {
count += it
}
return count
}
三十一、泛型
public class Bean<T extends String> {
T data;
public Bean(T t) {
this.data = t;
}
}
Bean<String> bean = new Bean<>("666666");class Bean<T : Comparable<String>>(t: T) {
var data = t
}
var bean = Bean<String>("666666")
// 换种更简洁的写法
var bean = Bean("666666")
三十二、构造代码块
public class MainActivity extends AppCompatActivity {
int number;
{
number = 1;
}
}class MainActivity : AppCompatActivity() {
var number = 0
init {
number = 1
}
}
三十三、静态代码块
public class MainActivity extends AppCompatActivity {
static int number;
static {
number = 1;
}
}class MainActivity : AppCompatActivity() {
companion object {
var number = 0
init {
number = 1
}
}
}
三十四、方法代码块
void test(){
{
int a = 1;
}
}fun test() {
run {
var a =1
}
}
三十五、可见修饰符
Java 的写法（默认为 default）
修饰符 作用
public 所有类可见
protected 子类可见
default 同一包下的类可见
private 仅对自己类可见
Kotlin 的写法（默认为 public）
Kotlin的写法
修饰符 作用
public 所有类可见
internal 同 Module 下的类可见
protected 子类可见
private 仅对自己类可见
三十七、无需 findViewById
在布局中定义
<TextView
android:id="@+id/tv_content"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="Hello World!" />
直接设置 TextView 的文本tv_content.text = "改变文本"
三十八、Lambda表达式
Lambda 表达式虽然在 Java JDK 已经加上了，但是没有普及开来，
现在搭配 Kotlin 是一个不错的选择
tv_content.setOnClickListener(View.OnClickListener(
fun(v : View) {
v.visibility = View.GONE
}
))
现在可以用 Lambda 表达式进行简化
tv_content.setOnClickListener { v -> v.visibility = View.GONE }三十九、函数变量
在 Kotlin 语法中函数是可以作为变量进行传递的var result = fun(number1 : Int, number2 : Int) : Int { return number1 + number2 }使用这个函数变量
println(result(1, 2))
四十、空安全
在 Java 不强制我们处理空对象，所以常常会导致 NullPointerException 空指针出现，现在 Kotlin 对空对象进行了限定，必须在编译时处理对象是否为空的情况，不然会编译不通过
在对象不可空的情况下，可以直接使用这个对象
fun getText() : String {
return "text"
}
val text = getText()
print(text.length)在对象可空的情况下，必须要判断对象是否为空
fun getText() : String? {
return null
}
val text = getText()
if (text != null) {
print(text.length)
}如果不想判断是否为空，可以直接这样，如果 text 对象为空，则会报空指针异常，一般情况下不推荐这样使用
val text = getText()
print(text!!.length)还有一种更好的处理方式，如果 text 对象为空则不会报错，但是 text.length 的结果会= null
val text = getText()
print(text?.length)
四十一、方法支持添加默认参数
在 Java 上，我们可能会为了扩展某个方法而进行多次重载
public void toast(String text) {
toast(this, text, Toast.LENGTH_SHORT);
}
public void toast(Context context, String text) {
toast(context, text, Toast.LENGTH_SHORT);
}
public void toast(Context context, String text, int time) {
Toast.makeText(context, text, time).show();
}
toast("弹个窗");
toast(this, "弹个窗");
toast(this, "弹个窗", Toast.LENGTH_LONG);但是在 Kotlin 上面，我们无需进行重载，可以直接在方法上面直接定义参数的默认值
fun toast(context : Context = this, text : String, time : Int = Toast.LENGTH_SHORT) {
Toast.makeText(context, text, time).show()
}
toast(text = "弹个窗")
toast(this, "弹个窗")
toast(this, "弹个窗", Toast.LENGTH_LONG)
四十二、类方法扩展
可以在不用继承的情况下对扩展原有类的方法，例如对 String 类进行扩展方法
fun String.handle() : String {
return this + "Zhangsan"
}// 需要注意，handle 方法在哪个类中被定义，这种扩展只能在那个类里面才能使用
print("ZS = ".handle())
打印：ZS = ZhangSan
四十三、运算符重载
在 Kotlin 中使用运算符最终也会调用对象对应的方法，我们可以通过重写这些方法使得这个对象支持运算符
var a = 0
运算符 调用方法
+a a.unaryPlus()
-a a.unaryMinus()
!a a.not()
运算符 调用方法
a++ a.inc()
a– a.dec()
运算符 调用方法
a + b a.plus(b)
a - b a.minus(b)
a * b a.times(b)
a / b a.div(b)
a % b a.rem(b), a.mod(b) (deprecated)
a…b a.rangeTo(b)
运算符 调用方法
a in b b.contains(a)
a !in b !b.contains(a)
运算符 调用方法
a[i] a.get(i)
a[i, j] a.get(i, j)
a[i_1, …, i_n] a.get(i_1, …, i_n)
a[i] = b a.set(i, b)
a[i, j] = b a.set(i, j, b)
a[i_1, …, i_n] = b a.set(i_1, …, i_n, b)
运算符 调用方法
a() a.invoke()
a(i) a.invoke(i)
a(i, j) a.invoke(i, j)
a(i_1, …, i_n) a.invoke(i_1, …, i_n)
运算符 调用方法
a += b a.plusAssign(b)
a -= b a.minusAssign(b)
a *= b a.timesAssign(b)
a /= b a.divAssign(b)
a %= b a.remAssign(b), a.modAssign(b) (deprecated)
运算符 调用方法
a == b a?.equals(b) ?: (b === null)
a != b !(a?.equals(b) ?: (b === null))
运算符 调用方法
a > b a.compareTo(b) > 0
a < b a.compareTo(b) < 0
a >= b a.compareTo(b) >= 0
a <= b a.compareTo(b) <= 0
四十四、扩展函数
扩展函数是 Kotlin 用于简化一些代码的书写产生的，其中有 let、with、run、apply、also 五个函数
1、let 函数
在函数块内可以通过 it 指代该对象。返回值为函数块的最后一行或指定return表达式
一般写法
fun main() {
val text = "CurvedBowZhang"
println(text.length)
val result = 1000
println(result)
}let 写法：
fun main() {
val result = "CurvedBowZhang".let {
println(it.length)
1000
}
println(result)
}最常用的场景就是使用let函数处理需要针对一个可null的对象统一做判空处理
mVideoPlayer?.setVideoView(activity.course_video_view)
mVideoPlayer?.setControllerView(activity.course_video_controller_view)
mVideoPlayer?.setCurtainView(activity.course_video_curtain_view)
mVideoPlayer?.let {
it.setVideoView(activity.course_video_view)
it.setControllerView(activity.course_video_controller_view)
it.setCurtainView(activity.course_video_curtain_view)
}又或者是需要去明确一个变量所处特定的作用域范围内可以使用
2、with 函数
和前面的几个函数使用方式略有不同，因为它不是以扩展的形式存在的。它是将某对象作为函数的参数，在函数块内可以通过 this 指代该对象。返回值为函数块的最后一行或指定return表达式
定义 Person 类
class Person(var name : String, var age : Int)一般写法
fun main() {
var person = Person("CurvedBowZhang", 100)
println(person.name + person.age)
var result = 1000
println(result)
}with 写法
fun main() {
var result = with(Person("CurvedBowZhang", 100)) {
println(name + age)
1000
}
println(result)
}适用于调用同一个类的多个方法时，可以省去类名重复，直接调用类的方法即可，经常用于 Android 中RecyclerView中onBinderViewHolder中，数据 model 的属性映射到 UI 上
override fun onBindViewHolder(holder: ViewHolder, position: Int){
val item = getItem(position)?: return
holder.nameView.text = "姓名：${item.name}"
holder.ageView.text = "年龄：${item.age}"
}
override fun onBindViewHolder(holder: ViewHolder, position: Int){
val item = getItem(position)?: return
with(item){
holder.nameView.text = "姓名：$name"
holder.ageView.text = "年龄：$age"
}
}3、run 函数
实际上可以说是let和with两个函数的结合体，run函数只接收一个lambda函数为参数，以闭包形式返回，返回值为最后一行的值或者指定的return的表达式
一般写法
var person = Person("CurvedBowZhang", 100)
println(person.name + "+" + person.age)
var result = 1000
println(result)run 写法
var person = Person("CurvedBowZhang", 100)
var result = person.run {
println("$name + $age")
1000
}
println(result)适用于let,with函数任何场景。
因为run函数是let,with两个函数结合体，准确来说它弥补了let函数在函数体内必须使用it参数替代对象，在run函数中可以像with函数一样可以省略，直接访问实例的公有属性和方法；
另一方面它弥补了with函数传入对象判空问题，在run函数中可以像let函数一样做判空处理，这里还是借助 onBindViewHolder 案例进行简化
override fun onBindViewHolder(holder: ViewHolder, position: Int){
val item = getItem(position)?: return
holder.nameView.text = "姓名：${item.name}"
holder.ageView.text = "年龄：${item.age}"
}
override fun onBindViewHolder(holder: ViewHolder, position: Int){
val item = getItem(position)?: return
item?.run {
holder.nameView.text = "姓名：$name"
holder.ageView.text = "年龄：$age"
}
}4、apply 函数
从结构上来看apply函数和run函数很像，唯一不同点就是它们各自返回的值不一样，run函数是以闭包形式返回最后一行代码的值，而apply函数的返回的是传入对象的本身
一般写法
val person = Person("CurvedBowZhang", 100)
person.name = "ZJX"
person.age = 50apply 写法
val person = Person("CurvedBowZhang", 100).apply {
name = "ZJX"
age = 50
}整体作用功能和run函数很像，唯一不同点就是它返回的值是对象本身，而run函数是一个闭包形式返回，返回的是最后一行的值。正是基于这一点差异它的适用场景稍微与run函数有点不一样。
apply一般用于一个对象实例初始化的时候，需要对对象中的属性进行赋值。或者动态inflate出一个XML的View的时候需要给View绑定数据也会用到，这种情景非常常见。特别是在我们开发中会有一些数据model向View model转化实例化的过程中需要用到
mRootView = View.inflate(activity, R.layout.example_view, null)
mRootView.tv_cancel.paint.isFakeBoldText = true
mRootView.tv_confirm.paint.isFakeBoldText = true
mRootView.seek_bar.max = 10
mRootView.seek_bar.progress = 0
使用 apply 函数后的代码是这样的
mRootView = View.inflate(activity, R.layout.example_view, null).apply {
tv_cancel.paint.isFakeBoldText = true
tv_confirm.paint.isFakeBoldText = true
seek_bar.max = 10
seek_bar.progress = 0
}
多层级判空问题
if (mSectionMetaData == null || mSectionMetaData.questionnaire == null || mSectionMetaData.section == null) {
return;
}
if (mSectionMetaData.questionnaire.userProject != null) {
renderAnalysis();
return;
}
if (mSectionMetaData.section != null && !mSectionMetaData.section.sectionArticles.isEmpty()) {
fetchQuestionData();
return;
}kotlin的apply函数优化
mSectionMetaData?.apply {
//mSectionMetaData不为空的时候操作mSectionMetaData
}?.questionnaire?.apply {
//questionnaire不为空的时候操作questionnaire
}?.section?.apply {
//section不为空的时候操作section
}?.sectionArticle?.apply {
//sectionArticle不为空的时候操作sectionArticle
}5、also 函数
also函数的结构实际上和let很像唯一的区别就是返回值的不一样，let是以闭包的形式返回，返回函数体内最后一行的值，如果最后一行为空就返回一个Unit类型的默认值。而also函数返回的则是传入对象的本身
fun main() {
val result = "CurvedBowZhang".let {
println(it.length)
1000
}
println(result) // 打印：1000
}
fun main() {
val result = "CurvedBowZhang".also {
println(it.length)
}
println(result) // 打印：CurvedBowZhang
}适用于let函数的任何场景，also函数和let很像，只是唯一的不同点就是let函数最后的返回值是最后一行的返回值而also函数的返回值是返回当前的这个对象。一般可用于多个扩展函数链式调用
通过以上几种函数的介绍，可以很方便优化 Kotlin 中代码编写，整体看起来几个函数的作用很相似，但是各自又存在着不同。使用的场景也有相同的地方，比如：run函数就是let和with的结合体。
一张图说明：
四十五、协程
子任务协作运行，优雅的处理异步问题解决方案
协程实际上就是极大程度的复用线程，通过让线程满载运行，达到最大程度的利用CPU，进而提升应用性能
在当前 app module 中配置环境和依赖（因为现在协程在 Kotlin 中是实验性的）
kotlin {
experimental {
coroutines 'enable'
}
}
dependencies {
implementation 'org.jetbrains.kotlinx:kotlinx-coroutines-core:0.20'
implementation 'org.jetbrains.kotlinx:kotlinx-coroutines-android:0.20'
}
协程的三种启动方式
1.runBlocking:T
2.launch:Job
3.async/await:Deferred1.runBlocking
runBlocking ：运行阻塞。用代码测试一下
println("测试是否为主线程" + (Thread.currentThread() == Looper.getMainLooper().thread))
println("测试开始")
runBlocking {
println("测试是否为主线程" + (Thread.currentThread() == Looper.getMainLooper().thread))
println("测试延迟开始")
delay(20000) // 因为 Activity 最长响应时间为 15 秒
println("测试延迟结束")
}
println("测试结束")17:02:08.686 System.out: 测试是否为主线程 true
17:02:08.686 System.out: 测试开始
17:02:08.688 System.out: 测试是否为主线程 true
17:02:08.688 System.out: 测试延迟开始
17:02:28.692 System.out: 测试延迟结束
17:02:28.693 System.out: 测试结束
runBlocking 运行在主线程，过程中 App 出现过无响应提示，由此可见 runBlocking 和它的名称一样，真的会阻塞当前的线程，只有等 runBlocking 里面的代码执行完了才会执行 runBlocking 外面的代码
2.launch
launch ：启动。用代码测试
println("测试是否为主线程" + (Thread.currentThread() == Looper.getMainLooper().thread))
println("测试开始")
launch {
println("测试是否为主线程" + (Thread.currentThread() == Looper.getMainLooper().thread))
println("测试延迟开始")
delay(20000)
println("测试延迟结束")
}
println("测试结束")17:19:17.190 System.out: 测试是否为主线程 true
17:19:17.190 System.out: 测试开始
17:19:17.202 System.out: 测试结束
17:19:17.203 System.out: 测试是否为主线程 false
17:19:17.203 System.out: 测试延迟开始
17:19:37.223 System.out: 测试延迟结束3.async
async ：异步。用代码测试
测试的时候是主线程，但是到了 launch 中就会变成子线程，这种效果类似 new Thread()，和 runBlocking 最不同的是 launch 没有执行顺序这个概念
println("测试是否为主线程" + (Thread.currentThread() == Looper.getMainLooper().thread))
println("测试开始")
async {
println("测试是否为主线程" + (Thread.currentThread() == Looper.getMainLooper().thread))
println("测试延迟开始")
delay(20000)
println("测试延迟结束")
}
println("测试结束")17:29:00.694 System.out: 测试是否为主线程 true
17:29:00.694 System.out: 测试开始
17:29:00.697 System.out: 测试结束
17:29:00.697 System.out: 测试是否为主线程 false
17:29:00.697 System.out: 测试延迟开始
17:29:20.707 System.out: 测试延迟结束这结果不是跟 launch 一样么？那么这两个到底有什么区别呢？，让我们先看一段测试代码
println("测试是否为主线程" + (Thread.currentThread() == Looper.getMainLooper().thread))
println("测试开始")
val async = async {
println("测试是否为主线程" + (Thread.currentThread() == Looper.getMainLooper().thread))
println("测试延迟开始")
delay(20000)
println("测试延迟结束")
return@async "666666"
}
println("测试结束")
runBlocking {
println("测试返回值：" + async.await())
}17:50:57.117 System.out: 测试是否为主线程 true
17:50:57.117 System.out: 测试开始
17:50:57.120 System.out: 测试结束
17:50:57.120 System.out: 测试是否为主线程 false
17:50:57.120 System.out: 测试延迟开始
17:51:17.131 System.out: 测试延迟结束
17:51:17.133 System.out: 测试返回值：666666这里就说明了 async 和 launch 还是有区别的，async 可以有返回值，通过它的 await 方法进行获取，需要注意的是这个方法只能在协程的操作符中才能调用
线程调度
协程也有类似 RxJava 的线程调度，先用 launch 试验一下
println("测试是否为主线程" + (Thread.currentThread() == Looper.getMainLooper().thread))
println("测试开始")
launch(CommonPool) { // 同学们，敲重点
println("测试是否为主线程" + (Thread.currentThread() == Looper.getMainLooper().thread))
println("测试延迟开始")
delay(20000)
println("测试延迟结束")
}
println("测试结束")18:00:23.243 System.out: 测试是否为主线程 true
18:00:23.244 System.out: 测试开始
18:00:23.246 System.out: 测试结束
18:00:23.246 System.out: 测试是否为主线程 false
18:00:23.247 System.out: 测试延迟开始
18:00:43.256 System.out: 测试延迟结束
Q：这个跟刚刚的代码有什么不一样吗？A：当然不一样，假如一个网络请求框架维护了一个线程池，一个图片加载框架也维护了一个线程池…，你会发现其实这样不好的地方在于，这些线程池里面的线程没有被重复利用，于是乎协程主动维护了一个公共的线程池 CommonPool，很好的解决了这个问题
Q：还有刚刚不是说能线程调度吗？为什么还是在子线程运行？
A：因为我刚刚只用了 CommonPool 这个关键字，再介绍另一个关键字 UI，光听名字就知道是啥了
println("测试是否为主线程" + (Thread.currentThread() == Looper.getMainLooper().thread))
println("测试开始")
launch(UI) {
println("测试是否为主线程" + (Thread.currentThread() == Looper.getMainLooper().thread))
println("测试延迟开始")
delay(20000)
println("测试延迟结束")
}
println("测试结束")18:07:20.181 System.out: 测试是否为主线程 true
18:07:20.181 System.out: 测试开始
18:07:20.186 System.out: 测试结束
18:07:20.192 System.out: 测试是否为主线程 true
18:07:20.192 System.out: 测试延迟开始
18:07:40.214 System.out: 测试延迟结束
813
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
