<?xml version="1.0" encoding="utf-8" ?><rss version="2.0"><channel><title><![CDATA[tigershin的专栏]]></title><description><![CDATA[Effective Java 3rd cn]]></description><link>https://blog.youkuaiyun.com/tigershin</link><language>zh-cn</language><generator>https://blog.youkuaiyun.com/</generator><copyright><![CDATA[Copyright &copy; tigershin]]></copyright><item><title><![CDATA[如何使用协程Flow定义链式调用DSL]]></title><link>https://blog.youkuaiyun.com/tigershin/article/details/97272371</link><guid>https://blog.youkuaiyun.com/tigershin/article/details/97272371</guid><author>tigershin</author><pubDate>Thu, 25 Jul 2019 16:59:15 +0800</pubDate><description><![CDATA[定义DSL
定义启动flow的函数：

    protected val _spinner: MutableLiveData&lt;Boolean&gt; by lazy { MutableLiveData&lt;Boolean&gt;() }
    val spinner: LiveData&lt;Boolean&gt;
        get() = _spinner
        
 ...]]></description><category></category></item><item><title><![CDATA[Kotlin协程高级技巧和诀窍]]></title><link>https://blog.youkuaiyun.com/tigershin/article/details/86482808</link><guid>https://blog.youkuaiyun.com/tigershin/article/details/86482808</guid><author>tigershin</author><pubDate>Tue, 29 Jan 2019 21:22:36 +0800</pubDate><description><![CDATA[Kotlin协程出奇地简单：仅仅让一些长期运行的操作放在launch里面，然后就好了，是这样的把？对于简单的情况，当然如此了。但是很快，并发和并行固有的复杂性开始积累。
当你深入协程战壕时，下面内容是你需要知道的。
取消 + 阻塞式的工作 = ]]></description><category></category></item><item><title><![CDATA[kotlin coroutine文档：共享可变状态和并发]]></title><link>https://blog.youkuaiyun.com/tigershin/article/details/86660907</link><guid>https://blog.youkuaiyun.com/tigershin/article/details/86660907</guid><author>tigershin</author><pubDate>Sat, 26 Jan 2019 23:03:21 +0800</pubDate><description><![CDATA[共享可变状态和并发
可以使用Dispatchers.Default等多线程调度程序并行执行协程。 它产生了所有常见的并发问题。 主要问题是同步访问共享可变状态。 在协程域中解决这个问题的一些解决方案类似于多线程世界中的解决方案，但其他解决方案却是独一无二的。
问题
让我们开启一百个协程，它们都做了一千次相同的动作。 我们还将测量完成时间以进行进一步比较：
suspend fun Coroutine...]]></description><category></category></item><item><title><![CDATA[kotlin coroutine文档：通道]]></title><link>https://blog.youkuaiyun.com/tigershin/article/details/86566339</link><guid>https://blog.youkuaiyun.com/tigershin/article/details/86566339</guid><author>tigershin</author><pubDate>Sat, 26 Jan 2019 20:37:32 +0800</pubDate><description><![CDATA[通道
延迟值提供了在协同程序之间传输单个值的便捷方法。 通道提供了一种传输值流的方法。
通道是kotlinx.coroutines的实验性的功能。 他们的API预计将在接下里的kotlinx.coroutines库更新中变化，并且可能会发生重大变化。
通道基础
Channel在概念上与BlockingQueue非常相似。 一个关键的区别是，它不是阻塞式的put操作，而是具有挂起的send，而不是阻...]]></description><category></category></item><item><title><![CDATA[kotlin coroutine文档：协程上下文和调度器]]></title><link>https://blog.youkuaiyun.com/tigershin/article/details/86470225</link><guid>https://blog.youkuaiyun.com/tigershin/article/details/86470225</guid><author>tigershin</author><pubDate>Fri, 18 Jan 2019 11:01:02 +0800</pubDate><description><![CDATA[Coroutine context and dispatchers
Coroutines always execute in some context which is represented by the value of CoroutineContext type, defined in the Kotlin standard library.
The coroutine context is...]]></description><category></category></item><item><title><![CDATA[kotlin coroutine文档：组合挂起函数]]></title><link>https://blog.youkuaiyun.com/tigershin/article/details/86427624</link><guid>https://blog.youkuaiyun.com/tigershin/article/details/86427624</guid><author>tigershin</author><pubDate>Sun, 13 Jan 2019 20:03:04 +0800</pubDate><description><![CDATA[组合挂起函数
这部分讲述组合挂起函数的不同方法
默认是顺序的
假设我们有两个在别处定义的挂起函数，它们做一些有用的东西，像某种服务请求或者计算。我们假设它们仅仅是有用的，但是为了说明这个例子，每个实际上仅仅延迟一秒：
suspend fun doSomethingUsefulOne(): Int {
    delay(1000L) // 假设我们在这里做一些有用的事情
    return 13...]]></description><category></category></item><item><title><![CDATA[kotlin coroutine文档：取消和超时]]></title><link>https://blog.youkuaiyun.com/tigershin/article/details/86409562</link><guid>https://blog.youkuaiyun.com/tigershin/article/details/86409562</guid><author>tigershin</author><pubDate>Sun, 13 Jan 2019 12:09:24 +0800</pubDate><description><![CDATA[取消和超时
这部分讲述协程的取消和超时
取消协程的执行
在一个长期运行的应用，你可能需要细粒度地控制后台协程。例如，一个用户可能关闭页面，这个页面启动了一个协程，它的结果现在不再需要了，它的运行应该要取消。launch函数返回一个Job，它可以用来取消运行的协程：
import kotlinx.coroutines.*

fun main() = runBlocking {
//例子开始
    ...]]></description><category></category></item><item><title><![CDATA[kotlin coroutine文档：基础]]></title><link>https://blog.youkuaiyun.com/tigershin/article/details/86372480</link><guid>https://blog.youkuaiyun.com/tigershin/article/details/86372480</guid><author>tigershin</author><pubDate>Sat, 12 Jan 2019 23:27:42 +0800</pubDate><description><![CDATA[协程基础
这部分讲述协程基础概念。
第一个协程
运行如下代码：
import kotlinx.coroutines.*

fun main() {
    GlobalScope.launch { // 在后台启动新协程，然后继续运行
        delay(1000L) // 非阻塞式延时1秒（默认时间单位是毫秒）
        println(&amp;amp;quot;World!&amp;amp;quot;) // 在延时后打印
  ...]]></description><category></category></item><item><title><![CDATA[Effective Java 3rd 条目28 列表优于队列]]></title><link>https://blog.youkuaiyun.com/tigershin/article/details/79552209</link><guid>https://blog.youkuaiyun.com/tigershin/article/details/79552209</guid><author>tigershin</author><pubDate>Sun, 16 Dec 2018 21:50:06 +0800</pubDate><description><![CDATA[队列在两个方向上与泛型不相同。首先，队列是协变的。这个听上去令人不安的单词意思仅仅是：如果Sub是Super的一个子类，那么队列类型Sub[]是Super[]的一个子类。相反，泛型是非协变的：对于任何两个不同类型Type1和Type2，List&amp;amp;amp;lt;Type1&amp;amp;amp;gt;既不是List&amp;amp;amp;lt;Type2&amp;amp;amp;gt;的一个子类，也不是它的超类[JLS, 4.10; Naftalin07, 2.5]。你可能...]]></description><category></category></item><item><title><![CDATA[Kotlin Coroutines 模式与反模式]]></title><link>https://blog.youkuaiyun.com/tigershin/article/details/85039364</link><guid>https://blog.youkuaiyun.com/tigershin/article/details/85039364</guid><author>tigershin</author><pubDate>Sun, 16 Dec 2018 21:17:03 +0800</pubDate><description><![CDATA[原文在此,可能需要翻墙
文章目录简介处理异常时，用coroutineScope或者使用SupervisorJob包装异步调用主协程最好选择Main调度器避免使用多余的async/await避免取消域的job避免编写用隐式调度器的挂起函数避免使用全局域
简介
决定写一些东西，在我看来当你使用Kotlin coroutines时，这些东西你应该做和不应该做(或者说，至少试着避免做)。
处理异常时，用c...]]></description><category></category></item><item><title><![CDATA[Cocos creator 大厅子游戏和热更新]]></title><link>https://blog.youkuaiyun.com/tigershin/article/details/84946209</link><guid>https://blog.youkuaiyun.com/tigershin/article/details/84946209</guid><author>tigershin</author><pubDate>Mon, 10 Dec 2018 20:50:01 +0800</pubDate><description><![CDATA[工作中，需要把cocos creator创建的多个游戏适配到Android和ios应用中，经过调研，可以利用大厅子游戏模式实现。大厅本身作为一个游戏工程，可以有加载页面，和热加载子游戏。
热更新：
https://www.jianshu.com/p/9fc813fe9e4c
大厅子游戏：
https://www.jianshu.com/p/fe54ca980384
如何动态加载和更新子游戏：
自从...]]></description><category></category></item><item><title><![CDATA[Effective Java 3rd 条目27 消除非受检警告]]></title><link>https://blog.youkuaiyun.com/tigershin/article/details/79467907</link><guid>https://blog.youkuaiyun.com/tigershin/article/details/79467907</guid><author>tigershin</author><pubDate>Mon, 12 Mar 2018 22:12:12 +0800</pubDate><description><![CDATA[当你用泛型编程时，你将会看见许多编译器警告：非受检强转警告、非受检方法调用警告、非受检参数化vararg类型警告和非受检转换警告。你多熟悉泛型一些，你将获得更少警告，但是不要期待这些新代码干净利索地编译。

许多非受检警告容易消除。例如，假设你不慎编写如下声明：

Set&amp;lt;Lark&amp;gt; exaltation = new HashSet();

编译器会轻轻地告诉你做错了什么：

Vene...]]></description><category></category></item><item><title><![CDATA[Effective Java 3rd 条目26 不要使用原生类型]]></title><link>https://blog.youkuaiyun.com/tigershin/article/details/79417936</link><guid>https://blog.youkuaiyun.com/tigershin/article/details/79417936</guid><author>tigershin</author><pubDate>Tue, 06 Mar 2018 22:55:43 +0800</pubDate><description><![CDATA[首先，一些术语。类或者接口，它的声明有一个或者多个类型参数(type parameter)，是泛型(generic)类或者接口[JLS, 8.1.2, 9.1.2]。例如，List接口有一个类型参数，E，代表它的元素类型。这个接口的完整名字是List&amp;lt;E&amp;gt;(读作“E的列表”)，但是人们常常简单地叫它为List。泛型类和接口全部叫做泛型类型。

每个泛型类型定义了参数化(paramete...]]></description><category></category></item><item><title><![CDATA[Effective Java 3rd 条目25 将源文件限制在单个顶层类]]></title><link>https://blog.youkuaiyun.com/tigershin/article/details/79394245</link><guid>https://blog.youkuaiyun.com/tigershin/article/details/79394245</guid><author>tigershin</author><pubDate>Tue, 27 Feb 2018 23:06:29 +0800</pubDate><description><![CDATA[虽然Java编译器让你在单个源文件中定义多个顶层类，但是这么做没有任何益处。危险性来自这个事实：在单个源文件中定义多个顶层类，使得为一个类提供多个定义变得可能。使用哪个定义，受传递到编译器的源文件顺序的影响。

为了使得这具体些，考虑如下源文件，它仅仅包含了一个Main类，这个类引用另外两个顶层类(Utensil和Dessert)的成员：



public class Main { 
    p...]]></description><category></category></item><item><title><![CDATA[Effective Java 3rd 条目24 静态成员类优于非静态]]></title><link>https://blog.youkuaiyun.com/tigershin/article/details/79376553</link><guid>https://blog.youkuaiyun.com/tigershin/article/details/79376553</guid><author>tigershin</author><pubDate>Tue, 27 Feb 2018 22:52:10 +0800</pubDate><description><![CDATA[嵌套类(nested class)是一个定义在另外一个类内部的类。嵌套类应该仅仅是为了服务外部类而存在。如果内嵌类在其他某些情形下有用，那么他应该是一个顶层类。有四种嵌套类：静态成员类(static member class)、非静态成员类(nonstatic member class)、匿名类(anonymous class)和本地类(local class)。只有第一种是被认为是内部类。这个条...]]></description><category></category></item><item><title><![CDATA[Effective Java 3rd 条目23 类层级优于标签类]]></title><link>https://blog.youkuaiyun.com/tigershin/article/details/79373673</link><guid>https://blog.youkuaiyun.com/tigershin/article/details/79373673</guid><author>tigershin</author><pubDate>Mon, 26 Feb 2018 09:56:43 +0800</pubDate><description><![CDATA[偶尔，你可能遇见一个类，它的实例有两个或者更多的特点(flavor)，而且包含了一个标签(tag)域表明这个实例的特点。比如，考虑如下类，它可以代表一个圆形或者长方形：// 标签类 - 大大次于类层级! 
class Figure { enum Shape { RECTANGLE, CIRCLE };
    // 标签域 - 这个图形的形状 
    final Shape shape;    /]]></description><category></category></item><item><title><![CDATA[Effective Java 3rd 条目22 仅仅定义类型时使用接口]]></title><link>https://blog.youkuaiyun.com/tigershin/article/details/79361071</link><guid>https://blog.youkuaiyun.com/tigershin/article/details/79361071</guid><author>tigershin</author><pubDate>Sat, 24 Feb 2018 13:56:08 +0800</pubDate><description><![CDATA[当一个类实现一个接口时，这个接口起一个类型的作用，可以被用来引用这个类的实例。一个类实现了一个接口，应该因此说明一些事情：使用这个类的实例，一个类可以做什么。为任何其他目的而定义一个接口，都是不恰当的。 
不符合这个检测的一种接口是所谓的常量接口(constant interface)。这样的接口不包含任何方法；它仅仅包含静态final域，每个域导出一个常量。使用这些常量的类实现这个接口，避免了用...]]></description><category></category></item><item><title><![CDATA[Effective Java 3rd 条目21 为后代设计接口]]></title><link>https://blog.youkuaiyun.com/tigershin/article/details/79360926</link><guid>https://blog.youkuaiyun.com/tigershin/article/details/79360926</guid><author>tigershin</author><pubDate>Sat, 24 Feb 2018 13:46:15 +0800</pubDate><description><![CDATA[在Java8之前，添加方法到接口而没有破坏已存实现，是不可能的。如果你添加了一个新方法到接口，已存实现通常缺少这个方法，导致编译时期错误。在Java8中，添加了默认方法构造(default method construct)[JLS 9.4]，让方法添加到已存接口。但是添加新方法到已存接口充满了危险性。

默认方法的声明包括一个默认实现(default implementation)，实现接口的所...]]></description><category></category></item><item><title><![CDATA[Effective Java 3rd 条目20 接口优于抽象类]]></title><link>https://blog.youkuaiyun.com/tigershin/article/details/79222965</link><guid>https://blog.youkuaiyun.com/tigershin/article/details/79222965</guid><author>tigershin</author><pubDate>Tue, 13 Feb 2018 22:45:48 +0800</pubDate><description><![CDATA[Java有两个机制定义允许多个实现的类型：接口和抽象类。因为在Java8中引入了接口的默认方法(default method)[JLS 9.4.3]，所以两个机制都让你可以为一些实例方法提供实现。主要的区别在于，为了实现由抽象类定义的类型，一个类必须是这个抽象类的子类。因为Java仅仅允许单继承，抽象类的限制严重约束了作为类型定义的使用。定义所有必需方法和遵从通用规范的任何类，允许实现一个接口，而...]]></description><category></category></item><item><title><![CDATA[Effective Java 3rd 条目19 为继承设计和文档化，否则禁止它]]></title><link>https://blog.youkuaiyun.com/tigershin/article/details/79182405</link><guid>https://blog.youkuaiyun.com/tigershin/article/details/79182405</guid><author>tigershin</author><pubDate>Wed, 31 Jan 2018 22:03:21 +0800</pubDate><description><![CDATA[条目18使你意识到子类化一个“不熟悉的”类的危险性，该类不是为继承设计和文档化。那么一个类是为继承设计和文档化，是什么意思呢？

首先，类必须清晰地文档化覆写任何方法的影响。换句话说，类必须文档化可覆写方法的它的自用性(self-use)。对于每个公开或者受保护的方法，文档必须表明这方法调用了哪个可覆写方法、是什么顺序，而且每个调用的结果怎么影响了后续处理。(对于可覆写的(overridable)]]></description><category></category></item></channel></rss>