标签: multithreading

在我的应用程序中,我得到了一个点,在横向模式下,我需要附加两个片段.为了做到这一点,第二个片段需要等到第一个片段被添加(添加)之后才被添加.原因是第一个片段需要执行第二个片段所需的功能.我设法通过一个线程来做到这一点,但在这种情况下它只等待指示的时间,在附加第二个片段之前,如果第一个片段没有在给定的时间附加,应用程序将粉碎,因为第二个片段没有必要的数据.

任何更好的做法(例子)然后是下面的代码(比如等到第一个片段被连接,而且在某个时间间隔没有)？:

getSupportFragmentManager()
                .beginTransaction()
                .replace(R.id.mainContent, fragment).commit();
        Thread thread = new Thread() {
            @Override
            public void run() {
                try {
                    synchronized (this) {
                        wait(1000);
                    }
                } catch (InterruptedException e) {

                }
                if (isLandscape) {
                openSecondFragment(mIndex, R.id.rightConent);
                }
            }
        };
        thread.start();

非常感激.

我需要在第一个片段中执行处理程序:

@SuppressLint("HandlerLeak")
protected void loadAccountList() {

    LoadAccountList loadAccountListThread = new LoadAccountList(new Handler() {

        @SuppressWarnings("unchecked")
        public void handleMessage(Message msg) {
            switch (msg.what) {
            case LOAD_SUCCESSFUL_CODE:
                items = (ArrayList<Account>) msg.obj;
                break;
            case LOAD_FAILED_IOEXCEPTION_CODE:
                getActivity().showDialog(ERROR_DIALOG);
                break;
            default:
                break;
            }
        }
    });
    loadAccountListThread.start();

请不要关闭这个,恕我直言这是体面的,可能有用的编程问题.

请我阅读很多东西,因为我读了不同的意见和不同的方法,我感到很困惑.

问题如下:

在getView()一个Adapter我需要执行一些异步操作,如检查在网络上的形成和更新基于该视图.

我使用了以下方法:

每次getView()都叫我开始了Thread

但我的做法为我赢得了很多批评:

/sf/answers/1993904181/

/sf/answers/1993903481/

/sf/answers/1993904601/

public View getView(int position, View convertView, ViewGroup parent) { 
    ViewHolder holder;            
    if (convertView == null) {                
        //...         
    } 
    else {                
        //...
    }     

    Thread th= new Thread(new Runnable() {

           @Override
           public void run() {
                mActivity.runOnUiThread(new Runnable() {
                    @Override
                    public void run() {

                        CheckSomeInfoOverTheInternet(url, new myCallback {


                            @Override
                            public void onSuccess() {
                            holder.textview.setText("OK");
                            }

                            @Override
                            public void onFailre() {
                            holder.textview.setText("NOT OK!!!!");
                            }    

                        });
                    }
                }); …

我是否创建了一个所有 SSL套接字共享的链,或者每个SSL上下文一个链(由任何相关的套接字共享)？

Boost.Asio SSL文档声明了这一点,但它没有提到上下文.我认为这意味着我必须只使用一个链,但我认为这是在OpenSSL支持多线程之前编写的.

SSL和线程

SSL流对象不执行自己的锁定.因此,必须在隐式或显式链中执行所有异步SSL操作.请注意,这意味着在单线程程序中不需要同步(因此不会产生锁定开销).

我很可能只有一个SSL上下文,但我想知道这个链是由SSL上下文还是全局网络服务所拥有的更合适.

我确实提供了一个处理程序CRYPTO_set_locking_callback,以防万一.

GNU函数asprintf(打印到分配的字符串)是否是线程安全的？

(IIC,基本上,这归结为是否malloc是线程安全的问题.)

考虑示例代码:

#define _GNU_SOURCE
#include <stdio.h>

#include "getValue.h"

char * getValue(int key) {
  char * value;
  asprintf(&value, "%d", key); // TODO: No error handling!
  // If memory allocation wasn't possible, or some other error occurs,  these  functions  will
  // return -1, and the contents of strp is undefined.
  return value;
}

在这里,我不触及任何全局变量.如果我getValue在并发线程中调用了怎么办？没有坏事会发生,他们会吗？

我试图扩展threading.Timer，以便可以从函数中获取返回值。我使用了该线程的解决方案并进行了修改（因为Timer（）已经带有* args和** kwargs了，我认为我不需要__init__再次传递它了）。代码完全像这样：

from threading import Timer

class CustomTimer(Timer):
    def __init__(self):
        super(CustomTimer, self).__init__()
        self._return = None

    def run(self):
        super(CustomTimer, self).run()
        self._return = self._Thread__target(*self._Thread__args, **self._Thread__kwargs)

    def join(self):
        super(CustomTimer, self).join()
        return self._return

然后我在运行主模块时遇到以下错误：

Traceback (most recent call last):
  File "main.py", line 43, in <module>
    from storage import *
  File "/home/mei/tmwAthena/manamarket/storage.py", line 13, in <module>
    from utils import ItemDB
  File "/home/mei/tmwAthena/manamarket/utils.py", line 142, in <module>
    class CustomTimer(Timer):
TypeError: Error when calling the metaclass bases
    function() argument 1 must be …

我是C#中异步方法的新手.我已经读过这些关键字async并await通过异步某些方法帮助使程序更具响应性.我有这个片段:

第一道路

    public static void Main()
    {
        Console.WriteLine("Hello!! welcome to task application");
        Console.ReadKey();
        Task<string> ourtask = Task.Factory.StartNew<string>(() =>
        {
            return "Good Job";
        });
        ourtask.Wait();
        Console.WriteLine(ourtask.Result);
        Console.ReadKey();
    }

第二种方式

 public static void Main()
        {
            Launch();
        }
        public static async void Launch()
        {
            Console.WriteLine("Hello!! welcome to task application");
            Console.ReadKey();
            Console.WriteLine(await GetMessage());
            Console.ReadKey();
        }

        public static Task<string> GetMessage()
        {
            return Task.Factory.StartNew<string>(() =>
                {
                    return "Good Job";
                });
        }

我需要知道 :

1. 这两种实现之间是否有区别(在并行性的概念中)？

2. 如果我可以创建任务并等待它完成,那么使用async和await关键字有什么好处？

我理解fail-fast(LinkedList)和故障安全(copyonwrite)迭代器,但是弱的一致性仍然是个谜.

文档说它可能反映了底层集合的变化,但不能保证.因此,我认为弱一致性不会创建支持集合的副本.(在并发Map中,它在同一个bucketarray上工作).

我假设如果一个线程A创建了一个迭代器并且经过了一半,那么当线程B将一个项目放到数组开头的桶中时,这个更改对于线程A的迭代器是不可见的.

如果B将该项放到数组的末尾,A就会看到它.

是否可能有一个nosuchelement例外？

如果线程A创建一个迭代器,然后遍历到一个项目X,它有一个下一个项目Y,然后jvm停止线程A并恢复线程B,谁删除Y.这对线程A是否可见(我想是这样,否则并发映射将不会'是线程安全的,但对其迭代器的实现方式一无所知),因为它对线程A不可见,那么它很容易引发异常.

简单的问题:

为什么这是首选:

public class Foo {

    final private static Object foo = new Object();

    public static void doSomething() {
        synchronized(Foo.foo) {
            //code
        }
    }
}

对此:

public class Foo {

    public static void doSomething() {
        synchronized(Foo.class) {
            //code
        }
    }
}

或这个:

public class Foo {

    public synchronized static void doSomething() {
        //code
    }
}

？

对我来说,这些看起来基本相同,所以我不确定什么是同步访问静态字段的最佳方法,或者为什么一个会比另一个好,但我听说第一个通常是首选.

我写了一个简单的脚本,它使用线程从服务中检索数据.

    __author__ = 'Igor'
import requests
import time
from multiprocessing.dummy import Pool as ThreadPool

ip_list = []
good_ip_list = []
bad_ip_list = []
progress = 0

with open('/tmp/ip.txt') as f:
    ip_list = f.read().split()

def process_request(ip):
    global progress
    progress += 1
    if progress % 10000 == 0:
        print 'Processed ip:', progress, '...'
    r = requests.get('http://*****/?ip='+ip, timeout=None)
    if r.status_code == 200:
        good_ip_list.append(ip)
    elif r.status_code == 400:
        bad_ip_list.append(ip)
    else:
        print 'Unknown http code received, aborting'
        exit(1)

pool = ThreadPool(16)
try:
    pool.map(process_request, ip_list)
except: …

我正在使用的库Message使用回调对象发出一系列对象.

interface MessageCallback {
    onMessage(Message message);
}

使用某个libraryObject.setCallback(MessageCallback)调用添加回调,并使用非阻塞libraryObject.start()方法调用启动该进程.

创建Observable<Message>将发出这些对象的最佳方法是什么？

怎么libraryObject.start()阻止？