小编Rit*_*esh的帖子

我正在经历共同惯例的概念,以及它在kotlin中的使用和实现.

我用Google搜索并阅读了几个答案,就其在架构和性能方面与线程的不同之处而言.

这里解释得很好,

"coroutine"和"thread"之间的区别？

很公平,合作例程很棒,没有内存开销,性能卓越,没有死锁,竞争条件等等,而且易于使用.

现在,这里有一些事情,我很困惑,并希望更清楚 -

1. 什么时候应该在Android中使用协同例程和线程？或者我应该坚持只是合作惯例？
2. 如果,我只是坚持使用协同例程,那么它将如何利用CPU核心,因为它在单个线程上运行.

协同例程很好用,但它如何利用多个内核来提高性能.

我是android新手,正在阅读文档和一些教程.

服务

开发人员指南说,当需要在后台运行长时间运行的任务时,应该使用它,比如音乐播放器.

的AsyncTask

创建一个工作线程来执行后台任务,比如使用数据获取api,然后通过UI线程通知它的onPostExecute()回调方法.

装载机

在单独的线程上执行操作,向侦听器注册并通知数据集更改.

供应商

通过在清单文件中公开数据来共享不同应用程序之间的数据.

SyncAdapter

用于在Android设备和Web服务器之间同步数据.

理论上,我理解上述概念,比如它们的用途.我很难把它们整理好像何时使用什么？他们最好用的是什么？在什么情况下应该使用什么？

对于缓存,我使用sqlite或库像volley和retrospice

正如我所说我是android初学者并试图理解这些概念.

任何帮助和建议将不胜感激.提前谢谢.

我有一个大小为N的数组,N <= 200.

这里的空间复杂性是多少？

O(1)或(N) - 考虑约束N.

我正在编写一个 android 库（SDK），它将由我的主应用程序使用。

主应用程序有自己的应用程序类，其中所有基本初始化都像（Dagger 和 Stetho 以及其他库）一样进行。

我的 SDK 有自己的基础应用程序类，其中应用程序级组件的初始化类似于 Dagger 2.10+（其中应用程序类实现 HasActivityInjector）以及 Stetho、Timber、LeakCanary 和其他一些应用程序级初始化。

android 中是否可以有两个应用程序类 - 我想不可以，因为为每个应用程序创建一个进程。

我想知道将 SDK 应用程序类合并到主应用程序类中的最佳/推荐方法是什么。

任何相同的帮助/建议都会很棒！

为什么每次我的可组合项失效时都会调用 SideEffect，但 LaunchedEffect 却不然？

sealed class SomeState {
 object Error:SomeState()
 data class Content(): SomeState
}

class MyViewModel:ViewModel {
  internal val response: MutableLiveData<SomeState> by lazy {
    MutableLiveData<SomeState>()
  }
}

// This is top-level composable, it wont be recomposed ever
@Composable
fun MyComposableScreen(
viewModel:MyVm,
launchActivity:()->Unit
){
  val someDialog = remember { mutableStateOf(false) }

  MyComposableContent()

  GenericErrorDialog(someDialog = someDialog)

  when (val state = viewModel.response.observeAsState().value) {
    // Query 1  
    is Content -> LaunchedEffect(Unit) { launchActivity() }
    Error -> {
      // Query 2
  // Gets called …

当进度条处于活动状态时禁用后台交互的正确方法/方法是什么。

  Box(
    modifier = Modifier.fillMaxSize(),
    contentAlignment = Alignment.Center
  ) {
    // Some content (when anyState is true, disable screen interaction)
    if(anyState){
       MaterialCircularProgressIndicator()
    }
  }

我知道这就是拦截器的工作方式，来自应用程序的请求通过 OkHttp 核心，通过改造包装器和 OkHttpp 核心调用来发出实际的网络请求，并通过改造包装器对应用程序拦截器响应进行网络响应。

有没有办法避免从应用程序拦截器调用实际请求，例如，在应用程序拦截器的某些场景中，检查请求 URL 是否是某个字符串，然后，在这种情况下，不要调用实际的网络请求并直接从应用程序拦截器返回硬编码的响应？

虽然我理解或认为我理解，喷气背包有哪些副作用。

It's any work done in composable which escapes the scope of the composable function

我理解做诸如 I/O 操作或在函数作用域之外改变变量、提供引用而不清除它（内存泄漏）或改变不可组合状态的局部变量之类的事情 - 这些都是副作用，因为它们可以由于重组而导致意外行为和泄漏，重组是不确定的并且可以运行多次。为了解决副作用，我们有效果处理程序。

考虑到上述所有内容，我需要在一些情况下进行一些澄清

• 副作用 - 如果对象发生变化，它是否适用于除组合对象之外的任何对象？正如在组合状态（mutableStateOf 等..）中不会导致副作用？为什么？
• 为什么回调/状态/事件提升到您的活动/片段/视图模型不会导致副作用？

例如

@Composable
fun MyComposable(
viewModel:MyViewModel,
launchSomeActivity:()->Unit
){
   var state by remember { mutableStateOf("") }
   state = "some string" // not a side-effect?

   viewModel.someStringObject = "a" // it's a side-effect?

   launchSomeActivity() // it's a side-effect?

   when(val screenState = viewModel.screenState.collectAsState().value){
      is ScreenState.Success -> launchSomeActivity() // not a side-effect. why?
      is ScreenState.Error -> state="some String" // not …

我在 Java 中采用了向上和向下转换的概念，它们也被称为扩大和缩小。

• UpCasting（扩展）从派生类到基类自动发生。即如果它有一个 is-a 关系。
• 必须明确地进行向下转换以进行运行时检查。

好的，我明白了概念和一切。但是，在这种情况下它是如何工作的？

public class ObjPair {
    Object first;
    Object second;

    public ObjPair(Object first, Object second) {
        this.first = first;
        this.second = second;
    }

    public Object getFirst() {
        return first;
    }    
    public Object getSecond() {
        return second;
    }

    public static void main(String[] args) {
        ObjPair objPair = new ObjPair("A",2.2); // Goes widning conversion
        System.out.println(objPair.getFirst());
        System.out.println(objPair.getSecond());
    }
}

ObjPair objPair = new ObjPair("A",2.2);

• 这是通过 upcast、String 到 object 和 Double 到 object，状态存储在 objPair 中。伟大的..！！！

现在，当我执行objPair.getFirst()和 …