You can define other threads by configuring the report widget.
您可以配置报告小部件来定义其他线程。
If any other threads were to read the values, you would see no change.
如果任何其他线程想要读取该值，将看不到任何变化。
If no other threads are available for execution, then processors may sit idle.
如果没有其他的线程可供执行，那么处理器就将空闲。
Also, many other threads and processes may be started to carry out various tasks.
同样，启动其他众多线程和进程来执行不同任务。
Usually, the main use of a semaphore is to synchronize a thread?s action with other threads.
通常，信号的主要用途是同步某个线程与其他线程的动作。
But once the previous lock is released, other threads are now free to modify the previous bucket.
然而前面的锁一旦被释放，其它的线程就将可以自由修改前面的bucket。
The calls act as a warning to other threads to go to sleep and wait their turn for the mutex lock.
这两个函数调用的作用就是警告其它线程，要它们继续睡眠并等待轮到它们对互斥对象加锁。
Unfortunately, weightless thread users need to pay attention to "playing nice" with other threads.
不幸的是，轻便线程用户需要注意“好好地处理”其它线程。
You can pass this object in to other methods -- in other threads -- and not worry about it at all.
可以将该对象传递到其他线程中的其他方法，而且根本无需担心。
Then, other threads can read this variable knowing that they will always see the most up-to-date value.
然后，其他线程可以读取这个变量，从而随时能够看到最新的温度值。
Once the thread has finished with the object, it releases it so that other threads can then gain access.
一旦该线程完成对该对象的处理之后，便释放该对象，以便其他线程可以进行访问。
Now that the mutex is unlocked, other threads can access and modify the linked list, possibly adding items.
现在互斥对象已被解锁，其它线程可以访问和修改已链接列表，可能还会添加项。
The first thread locks the mutex and appends data to the queue, while the other threads wait for their turn.
第一个线程锁住互斥并把数据添加到队列中，而其他线程等待轮到它们操作。
This will block the thread until all other threads have called the method, then they are released all at once.
这么做会引起阻塞，当所有线程都调用了这个方法后，便会同时释放所有线程。
The longer a synchronized code block requires for execution, the longer other threads wait to enter that block.
同步代码块所需的执行时间越长，其他线程等待进入该代码块的时间就越长。
These operations are "atomic;" they always happen together, without any other threads executing in between them.
这些操作是“原子操作”；它们总是一起执行，没有任何其他线程在它们之间执行。
The purpose of the sleep is to allow the garbage collector to finish up after it has released the other threads.
休眠的目的在于给垃圾回收器充分的时间，在释放其他线程之后完成工作。
If you want to change state in a way that other threads will see it, then you might want to use Clojure's atoms.
如果想以其他线程可见的方式来变更状态，可能需要采用Clojure的atoms。
However this isn't a good solution because it may lock out the other threads from being able to have fair access.
但是，这并非一个很好的解决方案，因为它可能会妨碍其他线程合法的访问。
For other threads waiting on the same mutex, this has a negative effect, because the wait time is now even longer.
这对于等待同一互斥锁的其他线程有不利影响，因为等待时间现在会更长。
There's the race condition caused by other threads banging on your collection while the add or remove is taking place.
当添加或移除元素时，存取集合的其他线程会引起竞争条件。
The one major difference, mentioned above, is that these blocking reads and writes can be interrupted by other threads.
唯一的主要差别，如上所述，是这些阻塞读和写可以被其它线程中断。
Thread data refers to session's thread information, the information about the primary and other threads of the session.
线程数据指的是会话的线程信息、有关该会话的基本线程和其他线程信息。
If main finishes before the threads it has created and exits with pthread_exit , the other threads continue to execute.
如果main在它创建的线程之前完成，并使用pthread_exit退出，那么其他线程将继续执行。
In this model, called Pipelining, the main thread is used to loop through the results as they are produced by the other threads.
在这个被称为“并行管道”的模型下，主线程将会在另一个线程产出结果的同时进行循环处理。
Different threads can successively call the function and modify the data without informing the other threads that are using the data.
不同的线程可能会先后调用那个函数，并且修改那些数据时不会通知其他正在使用此数据的线程。
To fix this problem, Android offers several ways to access the UI thread from other threads. Here is a list of methods that can help.
为了解决以上问题，Android提供了几种途径来从其它线程中访问UI线程。
Then net effect is that we will end up with a longer critical section which may result in other threads stalling and reduced throughput.
这种做法带来的真正效果是我们获得了一个更长的临界区，它可能导致其他线程受到拖延从而降低吞吐量。
Contention for these locks from other threads, and also locks to be acquired during finalization, might occur and can result in deadlock.
其他线程可能会争用这些锁和在终结期间将获取的锁，进而导致死锁。
Contention for these locks from other threads, and also locks to be acquired during finalization, might occur and can result in deadlock.
其他线程可能会争用这些锁和在终结期间将获取的锁，进而导致死锁。
应用推荐