标签: blocking

为什么如果我MessageBox()在我的消息循环中调用看似同步的Windows函数,循环本身不会像我调用Sleep()(或类似函数)那样冻结？为了说明我的观点,请采用以下骨架WndProc:

int counter = 0;

LRESULT CALLBACK WndProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
    switch (msg)
    {
        case WM_CREATE:
             SetTimer(hwnd, 1, 1000, NULL); //start a 1 second timer
             break;
        case WM_PAINT:
             // paint/display counter variable onto window
             break;
        case WM_TIMER: //occurs every second
             counter++;
             InvalidateRect(hwnd, NULL, TRUE); //force window to repaint itself
             break; 
        case WM_LBUTTONDOWN: //someone clicks the window
             MessageBox(hwnd, "", "", 0);
             MessageBeep(MB_OK); //play a sound after MessageBox returns
             break;
        //default …

我正在开发一个C#Winforms应用程序,应用程序的一部分将使用AsyncUpload将文件上传到web服务器(使用它,因为需要使用porgress回调),在C#程序中

我有一个简单的for循环调用上传功能

 for(int i=0;i < 10 ; i++)
{
  Uploadfun();
}

这种乐趣有些神奇:

Uploadfun()
  { 
  // Logic comes here

   // webClient.UploadFileAsync runs a 2nd thread to perform upload .. 
   webClient.UploadFileAsync(uri, "PUT", fileNameOnHD);  

 }

并且在完成异步上载时调用的回调

Upload_Completed_callback()
{
  //Callback event
}

编辑

逻辑顺序:

1. 乐趣被召唤(来自循环)
2. 有趣的逻辑被执行和完成..
3. 回到for循环
4. 当UploadFileAsync(在另一个线程中运行某些逻辑)结束时,最终将调用回调

问题是在第3点,当执行回到for循环时,我需要阻止循环继续,直到调用回调.

我正在使用MappedByteBuffer来加速文件读/写操作().我的问题如下:

1. 我不确定是否需要使用.force()方法将内容刷新到磁盘.似乎没有.force(),.getInt()仍然可以完美地工作(好吧,因为这是一个内存映射缓冲区,我假设.getInt()从磁盘中获取数据,这意味着数据已被刷新到磁盘已经.

2. .force()方法是阻塞方法吗？

3. 阻塞方法是同步块吗？

4. 无论是否调用.force()方法,都会有巨大的性能差异.手动调用.force()有什么好处？我们应该在哪种情况下使用它？我假设没有调用它,数据仍将被写入场景后面的磁盘.

5. 如果我们需要调用.force(),从另一个线程调用它有助于提高性能吗？由于同步问题,它会破坏数据吗？

   import java.io.FileNotFoundException; import java.io.IOException; import java.io.RandomAccessFile; import java.nio.MappedByteBuffer; import java.nio.channels.FileChannel; import java.nio.channels.FileChannel.MapMode;

公共类Main {

public static void main(String[] args) throws IOException {
    System.out.println("start");

    RandomAccessFile raf = new RandomAccessFile("test.map", "rw");
    FileChannel fc = raf.getChannel();
    MappedByteBuffer mbb = fc.map(MapMode.READ_WRITE, 0, 2000000);

    int total = 0;
    long startTime = System.currentTimeMillis();
    for (int i = 0; i < 2000000; i += 4) {
        mbb.putInt(i, i);
        //mbb.force();
        total += mbb.getInt(i);
    }
    long stopTime = System.currentTimeMillis();

    System.out.println(total);
    System.out.println(stopTime - startTime); …

我正在考虑用Rails编写Web应用程序.用户做出的每个请求都取决于被调用的外部API.这个外部API可以随机非常慢(2-3秒),因此显然会影响单个请求.

在代码等待外部API返回的这段时间内,是否会阻止进一步的用户请求？

只是为了进一步澄清,因为似乎有些混乱,这是我期待的模型:

1. Alice向我的网络应用程序发出请求.为此,将调用API服务器A. API服务器A很慢,需要3秒才能完成.
2. 在Rails应用程序调用API服务器A的等待时间内,Bob发出一个请求,该请求必须向API服务器B发出请求.

Ruby(1.9.3)解释器(或Rails 3.x框架中的某些东西)是否会阻止Bob的请求,要求他等到Alice的请求完成后？

我正在阅读JDK 7文档中的频道(这里),并偶然发现:

多路复用,非阻塞I/O,比面向线程更具可扩展性,阻塞I/O,[...]

关于为什么会这样,有一个简单的解释吗？

我想实现一个用于阻止移动号码的应用程序,用于接收或发送呼叫和消息.在我的应用程序中,我在EditText框中输入手机号码然后我点击一个按钮来阻止用户输入的手机号码.

我已经实现了一个活动类,如下所示:

public class BlockNumberActivity extends Activity {
    /** Called when the activity is first created. */
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);

        ((Button)findViewById(R.id.block)).setOnClickListener(new OnClickListener() {
            @Override
            public void onClick(View v) {
                String mobileNumer = ((EditText)findViewById(R.id.mobileNum)).getText().toString();
                //How to block entered mobileNumber
            }
        });

        ((Button)findViewById(R.id.unblock)).setOnClickListener(new OnClickListener() {
            @Override
            public void onClick(View v) {
                String mobileNumer = ((EditText)findViewById(R.id.mobileNum)).getText().toString();
                //How to unblock entered mobileNumber
            }
        });
    }
}

我想我们可以使用BroadcastReceiver.但我对它没有更多的了解.请告诉我如何实现阻止或解锁移动号码.请任何人帮我.....

我们正在写一个客户端和服务器(我认为是)非常简单的网络通信.多个客户端连接到服务器,然后服务器将数据发送回所有其他客户端.

服务器只是位于阻塞select循环中等待流量,当它到来时,将数据发送到其他客户端.这似乎工作得很好.

问题是客户.在阅读时,它有时会想要写一次.

但是,我发现如果我使用:

 rv = select(fdmax + 1, &master_list, NULL, NULL, NULL);

我的代码将阻塞,直到有新数据要读取.但有时(异步,来自另一个线程)我将在网络通信线程上写入新数据.所以,我希望我的select定期唤醒,让我检查是否有要写的数据,如:

if (select(....) != -1)
{
  if (FD_SET(sockfd, &master_list))
     // handle data or disconnect
  else
     // look for data to write and write() / send() those.
}

我尝试将选择设置为轮询模式(或荒谬的短暂超时):

// master list contains the sockfd from the getaddrinfo/socket/connect seq
struct timeval t;
memset(&t, 0, sizeof t);
rv = select(fdmax + 1, &master_list, NULL, NULL, &t);

但是发现那时客户端永远不会得到任何传入的数据.

我也尝试将socket fd设置为非阻塞,如:

fcntl(sockfd, F_SETFL, O_NONBLOCK);

但这并没有解决问题:

1. 如果我的客户端select()没有struct …

如果一种方法必须是阻止方法,我是否正确地认为如果我遗漏throws InterruptedException,我犯了一个错误？

简而言之:

• 阻塞方法应该包括throws InterruptedException另外一种常规方法.
• 阻塞方法可能会影响响应能力,因为很难预测它何时会完成,这就是它需要的原因throws InterruptedException.

那是对的吗？

如果执行CPU密集型任务,我认为每个核心有一个线程是最佳的.如果你有一个4核CPU,你可以运行4个CPU密集子程序实例而不会受到任何惩罚.例如,我曾经在四核CPU上实验性地运行了四个CPU密集型算法实例.每个过程最多四次没有减少.在第五个实例中,所有实例都需要更长

阻止操作的情况如何？假设我有一个包含1,000个网址的列表.我一直在做以下事情:

(请不要介意任何语法错误,我只是嘲笑这个)

my @threads;
foreach my $url (@urlList) {    
     push @threads, async {
         my $response = $ua->get($url);
         return $response->content;   
     }
}

foreach my $thread (@threads) {
    my $response = $thread->join;
    do_stuff($response); 
}

我基本上开始了与URL列表中的URL一样多的线程.如果有一百万个网址,则会启动一百万个主题.这是最优的,如果不是最佳线程数吗？对于可以等待的任何阻塞I/O操作(读取文件,数据库查询等),使用线程是一种很好的做法吗？

相关奖金问题

出于好奇,Perl线程的工作方式与Python相同,而且它是GIL吗？使用python来获得多线程的好处,并将所有内核用于CPU密集型任务,您必须使用多处理.

在Redis 4.0中,有一个新命令UNLINK用于删除Redis内存中的密钥.

此命令与DEL非常相似:它删除指定的键.就像DEL一样,如果密钥不存在则会被忽略.但是,该 命令在另一个线程中执行实际内存回收, 因此它不会阻塞,而DEL则是.这是命令名称的来源:命令只是从键空间取消链接键.实际删除将在以后异步发生.

所以总是(100%次)使用UNLINK而不是DEL,因为UNLINK是非阻塞的,不像DEL,对吗？