在下面的示例中,锁定是在实例变量employee上获得的(不在此),但在进入synchronized块时,TestClass1的Threads仍然被锁定.任何建议为什么这种行为.据我所知,如果它同步就应该被锁定.
public class TestClass{
public static void main(String args[]){
TestClass1 obj = new TestClass1();
Thread t1 = new Thread(obj, "T1");
Thread t2 = new Thread(obj, "T2");
t1.start();
t2.start();
}
}
class TestClass1 implements Runnable{
Employee employee = new Employee();
public void myMethod () {
synchronized (employee) {
try {
Thread.sleep(4000L);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
public void myOtherMethod() {
synchronized (employee) {
try {
Thread.sleep(4000L);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
@Override
public …我有一个应用程序,我在其中向硬件控制器发送命令,然后控制器响应该命令.在这里,我有一个命令队列,我逐个发送它们,现在我想同步发送所有命令,意味着当我收到第一个命令响应然后我只发送下一个命令.我有两种方法,一种用于发送命令,另一种用于处理接收到的命令.
当我尝试连接到互联网时,我得到android.os.NetworkOnMainThreadException错误.我知道android(HoneyComb以后)的更新版本不允许你在UI线程上执行网络IO这就是我使用AsyncTask的原因.no错误代码但运行时,我得到android.os.NetworkOnMainThreadException错误代码:
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.mainactivity);
new GetProductDetails().execute();
}
class GetProductDetails extends AsyncTask<String, String, String> {
/**
* Before starting background thread Show Progress Dialog
* */
@Override
protected void onPreExecute() {
super.onPreExecute();
pDialog = new ProgressDialog(MainActivity.this);
pDialog.setMessage("Loading product details. Please wait...");
pDialog.setIndeterminate(false);
pDialog.setCancelable(true);
pDialog.show();
}
/**
* Getting product details in background thread
* */
protected String doInBackground(String... params) {
// updating UI from Background Thread
runOnUiThread(new Runnable() {
public void run() {
// Check for success …你好伙计这是我的代码,我面临的问题是,尽管打电话notifyAll,它还没有释放锁,你能说出原因并告诉解决方案.我是线程新手.提前致谢.
class Lock1 {}
class Home1 implements Runnable {
private static int i = 0;
private Lock1 object;
private Thread th;
public Home1(Lock1 ob, String t) {
object = ob;
th = new Thread(this);
th.start();
}
public void run() {
synchronized (object) {
while (i != 10) {
++i;
System.out.println(i);
}
try {
// System.out.println("here");
object.wait();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println("here thread 1");
}
}
}
class Home2 implements Runnable …在创建简单的样本使用期间async/await,我发现,一些示例只是在Button1_Click类似的方法上说明模式,并直接从async方法中自由更新GUI控件.因此可以将此视为安全机制.但是,我的测试代码是不断地对崩溃TargetInvocationException的例外在mscorlib.dll与内部异常,如:NullReference,ArgumentOutOfRange等.关于堆栈跟踪,一切似乎都指向WinForms.StatusStrip显示结果(直接从驱动标签async绑定到按钮事件处理方法).Control.Invoke在访问GUI控件时使用旧学校时,崩溃似乎已得到解决.
问题是:我错过了重要的事情吗？异步方法是否与先前用于长期操作的线程/后台工作程序相同,因此Invoke是推荐的解决方案？直接从async方法错误驱动GUI的代码片段是什么？
编辑:对于缺失源的downvoters:创建一个包含三个按钮的简单表单和一个包含两个标签的StatusStrip ...
//#define OLDSCHOOL_INVOKE
using System;
using System.Threading.Tasks;
using System.Windows.Forms;
namespace AsyncTests
{
public partial class Form1 : Form
{
public Form1()
{
InitializeComponent();
}
private async void LongTermOp()
{
int delay;
int thisId;
lock (mtx1)
{
delay = rnd.Next(2000, 10000);
thisId = firstCount++;
#if OLDSCHOOL_INVOKE
Invoke(new Action(() =>
#endif
label1Gen.Text = …当多个线程同时访问数据时,必须同步访问以防止数据完整性问题.局部变量是否需要同步？
我创建了一个程序,它创建了1000个线程,每个线程将1加入到变量sum中.我的问题是我得到的输出只有1秒.
这是程序:
class Threading implements Runnable{
T6_Q1 sumObject=new T6_Q1();
Thread t;
Threading(){
t=new Thread(this);
t.start();
}
@Override
public void run() {
setSumValue();
System.out.println(sumObject.getSum());
}
public void setSumValue(){
Integer value=sumObject.getSum().intValue()+1;
sumObject.setSum(value);
}
}
public class T6_Q1
{
Integer sum =new Integer(0);
public void setSum(int value){
this.sum=new Integer(value);
}
//method to get the sum value
public Integer getSum(){
return this.sum;
}
public static void main(String[] args) {
//launches 1000 threads
for(int i=1;i<=1000;i++)
{
new Threading();
}
}
}
即使我同步setSumValue方法我只得到1s.我在这做错了什么？(我很新线程所以仍然有点难以理解错误)
感谢您的时间.
我在这里有一个简单的例子:
自从我尝试学习c ++ 11线程以来,该项目可称为学术性的.这是对正在发生的事情的描述.
想象一下,如果std::string有大量的汇编源代码,那就非常大
mov ebx,ecx;\r \nmov eax,ecx;\r \n ......
Parse()function接受此字符串并通过标记行的开头和结尾并将其保存string::const_iterators在作业队列中来查找所有行位置.
之后,2个工作线程从队列中弹出此信息,并将子字符串解析为Intstuction类对象.他们将结果的Instruction类实例推送到std::vector<Instruction> result
这是一个结构声明,用于保存要解析的子字符串的行号和迭代器
struct JobItem {
int lineNumber;
string::const_iterator itStart;
string::const_iterator itEnd;
};
那是一个小记录器......
void ThreadLog(const char* log) {
writeMutex.lock();
cout << "Thr:" << this_thread::get_id() << " " << log << endl;
writeMutex.unlock();
}
这是共享数据:
queue<JobItem> que;
vector<Instruction> result;
以下是同步的所有原语
condition_variable condVar;
mutex condMutex;
bool signaled = false;
mutex writeMutex;
bool done=false;
mutex resultMutex;
mutex queMutex;
每线程功能
void Func() {
unique_lock<mutex> condLock(condMutex); …c++ multithreading condition-variable thread-synchronization c++11
最近我发现Linux内核中的Sleep系统调用会将当前调用线程挂起到挂起/阻塞状态,这意味着他们不会在上述时间过去之前使用CPU.- 完全理解.
现在来到互斥和信号量,
互斥锁:
acquire() {
while (!available)
; // busy wait --> my doubt
available = false;;
}
release() {
available = true;
}
信号量锁定:
wait(S) {
while (S <= 0)
; // busy wait --> my doubt
S--;
}
signal(S) {
S++;
}
PS:这些代码片段取自ABRAHAM SILBERSCHATZ的"操作系统概念-9版"
我的问题:
我知道忙等待不是解决同步问题的有效方法,但是从上面提到的代码片段我怀疑使用互斥和信号量会在忙碌的等待中结束？(尽管互斥体和信号量被广泛用于解决大多数系统问题).
这让我觉得使用互斥锁和信号量不是解决同步问题的有效方法, 因为它会占用CPU周期(因为它不会导致挂起状态而是在while循环中旋转).
简而言之: 互斥和信号量是否会等待而不是将等待的线程线程置于挂起状态？
提前致谢 !!.如果我的理解错了,请纠正我!
operating-system mutex semaphore linux-kernel thread-synchronization
真的有必要lock.unlock()在一个finally街区吗？下面是一个常见的习语
try {
lock.lock();
// some code
} catch (Exception e) {
// exception handling
} finally {
lock.unlock();
}
然而，Java 语言规范是这样说的：
如果主体的执行曾经完成，无论是正常还是突然 [大概，例如由于异常]，都会在同一监视器上自动执行解锁操作。
那么真的有必要加lock.unlock()块吗？finally或者我误解了规范？