1回答
我正在学习Go，这是我正在编写的一个web应用程序的代码：
func init() {
db, err := sql.Open("mysql", "master:123456@/shopping_list")
if err != nil {
panic(err.Error())
}
http.HandleFunc("/sql", func(w http.ResponseWriter, r *http.Request) {
sqlHandler(w, r, db)
})
浏览 2提问于2014-04-15得票数 0
回答已采纳
我有一个应用程序，我希望将某些信息汇总到membase中，以避免昂贵的group by查询。例如，点击转换将记录在MySQL中，我希望在Memcache键中为某个用户保持按小时分组的总点击次数。在那里，我可以使用我需要的值取消/序列化一个数组。我有很多类似的收入，喜欢等其他需求。
创建某种“事务”以确保MC和Mysql保持同步的最佳方式是什么？我总是可以基于底层的MySQL存储重新构建密钥存储，但我希望在两个产品之间保持良好的并发性。
浏览 0提问于2012-01-23得票数 1
我使用的是MySQL5.5，当我执行如下查询时会发生什么：
Insert into A select * from B ;
同时其他进程将记录插入到表B中？InnoDB可以处理这种情况吗？表将在执行结束时同步吗？
谢谢！！
浏览 0提问于2015-04-13得票数 0
为了研究新的HP Gen8服务器(Intel(R) Xeon(R) CPU E5-2630 0 @ 2.30GHz)上的性能问题，我做了一些测试
我创建了两个表，第一个是使用InnoDB存储引擎，第二个是在Memory -堆表中。
系统详细信息：
sysbench-0.4.12-5.el6.x86_64
CentOS release 6.4 (Final)
制备阶段：
InnoDB
# sysbench --db-driver=mysql --test=oltp --mysql-table-engine=innodb --oltp-table-size=1000000 --mysql-db=s
浏览 0提问于2013-09-13得票数 2
回答已采纳
3回答
我有一个非常琐碎的mysql主->从设置在两个服务器之间进行。问题是，复制是异步的，这可能会导致问题(即使是在低延迟链接上)，如果主服务器在从从复制线程获取最后一个bin日志之前在提交之后崩溃的话。
是否需要强制mysql执行同步提交，以便在mysql->从关系中保证数据的一致性？
浏览 0提问于2009-10-17得票数 4
回答已采纳
1回答
在我的代码中，我需要执行以下操作：
如果存在特定行(匹配某些条件)，请检查MySQL表(InnoDB)。如果是的话，把它还回去。如果没有，创建它，然后返回它。
我似乎遇到的问题是种族条件。每隔一段时间，两个进程都会如此紧密地运行，以至于它们同时检查表，看不到行，并且都插入它--因此重复了数据。
我正在阅读MySQL文档，试图想出一些防止这种情况的方法。到目前为止，我得出的结论是：
唯一的索引似乎是一种选择，但它们并不是通用的(只有当条件对所有行都是唯一的时才有效)。
即使是在SERIALIZABLE级别的事务也不能防止INSERT，句号。
SELECT ... LOCK I
浏览 4提问于2017-11-06得票数 0
回答已采纳
3回答
java同步和异常处理
、、、
如果我有一个synchronized块，并且在该块中的某个位置抛出了一个未在synchronized块中捕获的异常，那么当异常传播出该块时，锁是否会被释放？( synchronized块)
synchronized( mutex )
{
throw new Exception( "" );
}
浏览 3提问于2011-12-04得票数 3
回答已采纳
2回答
当我OPTIMIZE、REPAIR或ANALYZE一个MySQL表时，这会停止所有其他操作直到进程完成(INSERT、SELECT等)吗？我应该经常ANALYZE一张桌子吗？
如果多个用户同时在我的站点的不同位置执行INSERT、UPDATE、SELECT等操作，那么所有的操作都会在负载高的情况下正常执行吗？或者我应该设置一些代码来确保它们得到正确的执行？
需要进一步澄清吗？我很乐意给你更多。
谢谢你的帮助。
浏览 3提问于2012-02-06得票数 0
回答已采纳
1回答
在MySQL中有一个表用户包括3个字段: ID (int)、Name (varchar)和UpdateTime (TimeStamp)。我有一个java应用程序和一个函数来获取表用户中的一条记录，在此之后，检查UpdateTime是否在当前时间之前-->按当前时间+2小时更新UpdateTime。
我的问题是，当有大约100个用户访问我的应用程序并请求该功能在同一时间内获得相同的记录时，所有用户都将更新UpdateTime。但我只希望第一次用户更新UpdateTime，迟来的人只会得到数据而不更新UpdateTime。
我怎么能做到呢？我真的不知道。
谢谢。
对不起，我的英语不太好。
浏览 3提问于2014-05-14得票数 0
回答已采纳
1回答
同步访问问题
、、、
我对同步有一些疑问：
如果我从同步方法调用非同步方法，非同步方法是否可以锁定，其他方法(实例方法)还能访问非同步方法吗？
如果我拥有类级锁，其他线程可以同时访问同步实例方法吗？
浏览 3提问于2020-07-14得票数 1
根据我的理解，非静态方法上的同步将在对象级别被阻塞，而静态方法上的同步将在类实例级别上被阻塞。
在此基础上，我对各种情况的理解如下：
非静态同步方法访问，那么其他非静态同步方法也会阻塞。
非静态同步方法访问，然后非静态非同步方法不阻塞。
该类实例的静态同步方法访问然后其他同步方法(静态和非静态)被阻塞。
静态同步方法访问，然后其他非静态非同步方法不阻塞。
静态同步方法访问，然后其他静态非同步方法不阻塞。
静态同步方法访问，然后对所有对象实例阻塞非静态同步方法。
非静态同步方法访问然后静态同步方法不阻塞
请帮我核实一下。
浏览 1提问于2013-12-30得票数 1
回答已采纳
我刚刚读了一个mysql文档，其中我发现了这样一句话：“一致读取意味着InnoDB使用多版本控制将呈现给查询，这是数据库的快照。”
我读了很多mysql文档页面，但仍然无法向我自己阐明“查询”的确切含义。毫无疑问，它会返回到SELECT语句，但是如果我的事务以UPDATE、INSERT、DELETE语句开始呢？
谢谢!
浏览 3提问于2015-01-09得票数 1
1回答
我想知道为什么Java需要synchronized块中的对象。即：
synchronized(object) {
// stuff
}
为什么我不能在不指定任何对象的情况下使用一个简单的块？例如：
synchronized {
// stuff
}
浏览 2提问于2020-05-13得票数 0
回答已采纳
我想知道当几个用户试图同时更新一个MySQL数据库时会发生什么。在网上了解了Transaction。
我是否需要定义事务语句。(START TRANSACTION,... COMMIT/ROLLBACK)对于我的每个数据库更新查询？是否有一种自动化的方法来实现这一点？
浏览 8提问于2022-04-02得票数 2
回答已采纳
4回答
我需要澄清几个基本的概念，以检查我的理解是否正确。
1)一旦线程进入实例上的任何同步方法，则其他线程不能在<code>E 110</代码>相同实例<代码>E 211</代码>上输入任何其他同步方法。
然而，2)上的非同步方法将继续是可调用的(由其他线程调用)。如果是，那么我可以说整个对象没有被锁定，而是只被同步的关键方法。
3)我是否也会得到与上述synchronized语句相同的行为：
synchronised(this){
// statements to be synchronised
}
或者整个对象在这里使用非同步方法锁
浏览 4提问于2015-03-31得票数 2
回答已采纳
public class Computation extends Thread {
private int num;
private boolean isComplete;
public Computation(int nu) {
num = nu;
}
public void run() {
System.out.println("Thread Called is: " + Thread.currentThread().getName());
}
public static voi
浏览 4提问于2014-08-23得票数 0
回答已采纳
我试图理解JAVA中的同步。我写了一个小程序。
class A implements Runnable {
public void run() {
Random r = new Random();
int i = r.nextInt(10);
if(i<5){
print();
}else{
display();
}
}
public synchronized void display()
浏览 0提问于2014-03-16得票数 0
回答已采纳
1回答
我有一个cron作业，每隔几分钟运行一次，它遍历“待办”列表中的前50项，在每个项目上运行一个脚本，并将其标记为在数据库中运行。
这是很好的工作，直到将项目标记为完整的表被某些东西锁定，而项目没有被标记掉。然后，这位官员又跑了一圈，检查了同样的50件物品。
这种情况不断重复，直到mysql中的进程列表变得庞大，并且每隔几分钟就会增加50个。
我怎么才能阻止这一切的发生？我的想法是：
向脚本中添加代码，查看cron在再次运行之前是否仍在运行。
在运行新的SELECT查询之前，检查已锁定表的mysql表，以获得接下来的50项
两者似乎都有起起落落，我不知道如何恰当地实施这两种方法。
浏览 0提问于2013-03-20得票数 0
回答已采纳
日志停止于logger.warn("Start: preparedStatement.executeQuery()")；并无限期地挂起。日志中没有抛出异常。查询没有出现在info列下的show FULL PROCESSLIST中，这意味着查询甚至没有执行。我可以在命令行中执行查询，返回所有行只需要不到一秒钟的时间。显示打开的表，其中IN_USE <> 0返回空集，因此没有表被锁定。使用JDK1.8、MySQL 1.6、InnoDB。*编辑:这是在AWS上运行的，我注意到在挂起之前CPU使用率出现了很大的峰值。
public void setup(StringBuil
浏览 0提问于2016-09-09得票数 0
3回答
假设有两个类，父类和子类扩展父类。现在，这两种方法都有两种方法，即synchronized.My :我创建的对象将使用哪个对象锁来锁定这个同步方法，比如:父p=new子()；父对象锁还是子对象锁？
浏览 3提问于2014-07-12得票数 4
回答已采纳
我有一个用于脱机备份的简单主从MySQL复制设置，我正在寻找一些关于如何调查两个可能相关的问题的指导：
每次运行MYSQLDUMP时，在复制服务器上读取relay_log时都会出错。我应该如何关心这件事，是否有办法防止它？下面提供了示例错误输出。[编辑:这个链接https://lists.mysql.com/replication/413似乎表明它是预期的行为。]
复制显示为重复主键错误的数据的错误。这让我非常担心，因为它会阻止复制死亡，意味着数据损坏，而我不明白原因。在两个不同的表中存在30+重复键。这些键是自动递增的，而且代码似乎并没有做什么傻事(它只在一个地方为两个表使用一个简单的INS
浏览 0提问于2018-08-05得票数 2
回答已采纳
5回答
我想知道在Java中，如果我在同一个对象上同步两次，会不会有什么奇怪的行为？
场景如下
pulbic class SillyClassName {
object moo;
...
public void method1(){
synchronized(moo)
{
....
method2();
....
}
}
public void method2(){
synchronized(moo)
{
浏览 3提问于2008-10-30得票数 57
回答已采纳
我一直对下面的场景感到困惑
只有一个MyClass对象，有两个线程T1，T2。现在，一个线程假设T2将能够使用同步的方法m1()，该方法拥有唯一的MyClass对象锁，而另一个线程T2如果试图访问m1()将被阻塞。
现在我的看法是，如果T2试图通过访问静态共享字段来访问静态同步方法m2()，那么它将被阻塞，因为当前的对象锁是使用T1的，并且不能执行m2()，如果Myclass有两个对象，那么T2线程将能够访问m1()。我是对还是错？
class MyClass
{
public static int i = 5;
public synchronize
浏览 0提问于2012-11-27得票数 1
回答已采纳
3回答
这个问题的重点是说明Java并没有像我预期的那样工作。
您希望以下代码的行为如何？
public class SynchTester {
private static SynchTester synchTester;
public synchronized static SynchTester getSynchTester(){
if(synchTester==null){
synchTester = new SynchTester();
}
return synchTester;
}
private SynchTester() {
浏览 5提问于2012-11-02得票数 31
回答已采纳
3回答
在这些Java情况下会出现死锁吗
1-
synchronized(obj) {
obj.syncMethod(); // the method signature: public synchronized void syncMethod() {...}
}
2-
synchronized(obj) {
if (condition)
throw new Exception(); // deadlock because obj lock is not released?
// do other stuff
}
谢谢。
浏览 0提问于2012-04-12得票数 1
回答已采纳
3回答
我在实践中读到了Java并发。
所以写着
When thread A executes a synchronized block, and subsequently thread B enters a synchronized block guarded by the same lock
两个线程如何一次锁定同一个对象？谢谢。
浏览 1提问于2014-03-16得票数 0
回答已采纳
访问子类对象的线程能否在同步块中对其父类静态变量使用锁，如果其他线程访问继承相同父类对象的其他子类对象，则是否已经对该静态变量使用了锁？
浏览 3提问于2016-03-18得票数 2
回答已采纳
假设我们有
class A {
void m1() {
synchronized (this) {
}
blah blah blah
synchronized (this) {
}
}
}
我怀疑在执行blah时，当前正在执行的带有对象o释放锁的线程，此时如果其他对象o的线程获得了锁，就会出现死锁。那么，我们怎么能说我们应该尝试使用同步块而不是同步方法呢？
假设执行静态同步方法的线程t1获得了类级锁，其他线程可以获取该类实例的锁来执行其他同步方法吗？
浏览 2提问于2013-10-07得票数 0
回答已采纳
1回答
这是一个死锁吗?请看代码
、、、
这是一个死锁吗？它似乎锁定了java.io.PrintStream很多。它的发生是非常随机的，如果你愿意看看的话。id为0x67804350的printstream对象被同一线程同时锁定。
"service-j2ee-247" prio=5 tid=0x00ea34b0 nid=0x13b runnable [1bb2d000..1bb2f678]
at java.nio.CharBuffer.wrap(CharBuffer.java:347)
at sun.nio.cs.StreamEncoder$CharsetSE.implWrite(StreamEncod
浏览 0提问于2011-10-24得票数 1
2回答
如果一个线程对对象的同步方法有两个调用。执行第一次调用时，线程将获得监视器锁。但这样的话，线会：
在完成第一次调用后释放锁，并在执行第二次调用时再次获得它？
或者，线程会一直保持锁直到第二次调用结束(不仅仅是第一次调用)。然后在最后放出来？
换句话说，线程会获得锁，完成对同步方法的所有调用，然后释放锁吗？或者线程是否应该获得多个锁的增益和释放？
浏览 0提问于2017-06-19得票数 1
回答已采纳
1回答
我正在开发一个基于控制台的Java应用程序。我必须向用户展示选择数据库的建议。我使用Scanner读取输入，使用单独的线程检查输入是否包含TAB，以便打印建议。
更新
按照下面的答案，我在代码中添加了同步块，异常就消失了。然而，我没有看到任何建议打印在控制台上。下面是我的当前代码：
import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;
class Test {
private static List<String> suggestions = new ArrayList&
浏览 3提问于2017-07-11得票数 1
1回答
具有数组的意外竞争条件
、、、、
我试图设计一个简单的咖啡机系统，它使用三种资源:牛奶、咖啡、水。
对于每个订单，我创建一个新线程，每个线程为每个资源创建另外三个线程，以便在顺序访问它们时不要等待空闲资源。
根据资源，我将它们存储在一个简单的数组中，并使用锁保护每个索引(它代表三个索引中的一个)，但不幸的是，当我打开TSAN时出现了一个竞争条件。
我确信没有两个线程会同时访问相同的索引，而且为了更有信心，我将资源从数组中的变量更改为独立的变量，并且没有发生竞争，那么为什么当通过锁保护每个索引时访问相同的数组会导致争用条件。
下面的代码具有资源数组(具有争用条件的代码)：
import Foundation
e
浏览 7提问于2022-09-24得票数 1
2回答
我有一个同步方法，如下所示：
static Object foo (Map m, String key) {
synchronized (m) {
//...
return m.get(key);
}
}
另一个调用此方法的方法是：
static void bar (Map m, Stirng key) {
synchronized (foo (m,key) ) {
//Is m still synchronized locked here?
//...
}
}
我的问题如上。由于同步块位于foo的返回值上，所以我想知道以下问题的答案：
只有
浏览 4提问于2015-10-05得票数 1
回答已采纳
3回答
据我所知，当类中有多个同步方法(包括静态方法和实例方法)时，java只允许一次运行一个这样的方法。但是，如果线程获取对象实例(或类)上的锁，然后在该对象内输入一个同步方法，然后调用同一个对象的另一个同步方法，又会怎样呢？我的意思是：
Class AA
{
..
..
synchronized void X()
{
Y();
}
synchronized void Y()
{
..
..
}
是否有任何线程退出方法X将永远阻塞？既然java不允许同时运行方法X和Y？
浏览 0提问于2015-06-10得票数 9
回答已采纳
1回答
我创建了一个简单的Logger类，它使用StreamWriter将文本附加到日志文件中。主程序是一个任务调度程序，它异步执行任务，并在执行成功与否时写入日志文件。程序从数据库中读取并将任务添加到列表中，ExecuteAll()方法异步执行该列表中的每个任务。如果读取\写入数据库或任务执行中的任何步骤出错，我将使用Logger.Error()。
当我运行程序时，一切都进行得很好，但是当我将Thread.Sleep(5000)添加到每个任务以模拟连接到API时，就会得到一个IOExecption。
System.IO.IOException: The process cannot access t
浏览 2提问于2020-05-12得票数 0
3回答
为了加深我对Java同步的认识，我的困惑开始于以下声明，摘自
Java中的每个对象都与一个监视器相关联，一个线程可以锁定或解锁监视器。..。如果同步方法的主体的执行一直在正常或突然完成，则会在同一监视器上自动执行解锁操作。
所以，我想象一个监视器就像一个圆顶，覆盖整个对象，并阻止两个线程同时访问它。说得更清楚一点，我认为
class MySync{
synchronized void foo(){}
void bar(){}
String x;
}
如果threadA访问并运行(同步) foo()方法5秒，它将“激活圆顶”，阻止threadB访问对象的任何其他成
浏览 21提问于2015-03-26得票数 2
回答已采纳
2回答
今天我被问到这个面试问题，无法回答。如果有Person类的两个实例，其中有一个同步的setAddress方法。现在，如果它只是一个对象，并且多个线程正在访问它，synchronized将确保一次只有一个方法可以访问它。
但是，如果有不同的对象，一个线程在进入方法之前不会等待另一个线程。
现在，我想让这个方法在Person对象的所有实例之间同步的问题是，我如何做到这一点？
浏览 0提问于2013-07-31得票数 8
3回答
如果我在两个方法中使用synchronize(this)，其中一个调用另一个方法，我是否会陷入死锁的情况，或者它会因为线程已经拥有锁而工作吗？
想象一下下面的类：
public class Test {
public void foo() {
synchronize(this) {
bar();
}
}
public void bar() {
synchronize(this) {
// do something
}
}
}
如您所见，有两个方法foo和bar，它们都依赖于同步。
当调用foo()时，将在(This)上获
浏览 1提问于2012-06-26得票数 4
回答已采纳
3回答
同步方法中的同步块
、、、
我正在查看第三方库中包含同步方法的一些代码，在这个方法中有一个同步块，它锁定一个实例变量。与此类似：
public class Foo {
final Bar bar = new Bar();
public synchronized void doSomething() {
// do something
synchronized(bar) {
// update bar
}
}
...
}
这有道理吗？如果是这样的话，在同步方法中使用同步语句有什么好处？
考虑到同步方法锁定了整个对象，我认为这是多余的。
浏览 0提问于2015-09-01得票数 7
回答已采纳
为什么下面的代码不会导致死锁？我的意思是在我调用getNumber(.)类测试的对象应该是锁定的，所以我应该不能访问getNumber2(.)。
class Test() {
synchronized int getNumber(int i){
return getNumber2(i);
}
synchronized int getNumber2(int i) {
return i;
}
public static void main(String[] args) {
System.out.printl
浏览 0提问于2013-03-04得票数 5
回答已采纳
2回答
监视器和锁的澄清
、、、、
我把同步的概念理解为: Java中的每个对象都有一个监视器和一个锁。锁是一个可以被线程获取或释放的实体，而监视器是一个实例的机制，它决定了线程是否可以获得对象上的锁。
我想澄清一下下面的例子。首先，我想创建两个对象：
MyClass obj1 = new MyClass();
MyClass obj2 = new MyClass();
是否每个实例都有自己的监视器和锁？还是共享的？
如果我在一个类上同步：
synchronized (MyClass.class) {
...
}
它会有什么样的表现？此同步是否会阻止获取obj1和obj2锁？如果有，Java中有没有锁的
浏览 0提问于2015-11-19得票数 2
4回答
public class ObjectCounter {
private static long numOfInstances = 0;
public ObjectCounter(){
synchronized(this){
numOfInstances++;
}
}
**public static synchronized long getCount(){
return numOfInstances;
}**
//vs//
**public static long getCount
浏览 1提问于2015-07-10得票数 5
回答已采纳
正如我们所知，当偏向锁升级到轻量级锁时，JVM将停止使用。
当轻量级Lock升级到重量级Lock时，JVM是否停止了这个世界？为什么？
浏览 1提问于2021-12-02得票数 0
2回答
我知道线程可以获得自己拥有的监视器--在Java中，同步锁是reentrant，如下面的示例所示。
我的查询是，如果我使用java.util.concurrent.locks.ReentrantLock API，它将产生相同的结果，我们是否可以在同步中使用死锁，但在java.util.concurrent.locks.ReentrantLock中却永远不会。
例如：
final Object[] objects = new Object[10]
public synchronized Object setAndReturnPrevious(int index, Object va
浏览 1提问于2017-04-01得票数 0
在MySQL中(使用InnoDB和REPEATABLE READ隔离级别)发出包含如下所示子查询的UPDATE语句时：
UPDATE bar INNER JOIN (SELECT i1, i2 FROM foo) inner
ON bar.b1 = inner.i1
SET bar.b2 = inner.i2)
InnoDB引擎是只锁定bar表中所有受影响的行，还是在整个查询期间锁定foo表中所有被访问的行(共享或独占)？
连接和子查询有什么区别吗？
浏览 4提问于2016-05-20得票数 2
扫码
添加站长 进交流群
领取专属 10元无门槛券
手把手带您无忧上云
相关资讯
热门标签
云服务器
ICP备案
对象存储
腾讯会议
实时音视频活动推荐
腾讯云开发者
