package com.yan.threads;
public class TestThread {
public static void main(String[] args) {
//同一对象：this,class //不能并发
/*MyThread myThread = new MyThread();
Thread t1 = new Thread(myThread, "t1");
t1.start();
processThread(myThread);*/
//同一对象:class,class //同一锁竞争，不能并发
/*MyThread myThread = new MyThread();
Thread t1 = new Thread(myThread, "t1");
t1.start();
processThread(myThread);*/
//同一对象:this,this //同一锁竞争，不能并发
MyThread myThread = new MyThread();
Thread t1 = new Thread(myThread, "t1");
t1.start();
processThread(myThread);
//不同对象:this,this //可以并发
/*MyThread myThread = new MyThread();
MyThread myThread2 = new MyThread();
Thread t1 = new Thread(myThread, "t1");
t1.start();
processThread(myThread2);*/
//不同对象:class,this //可以并发
/*MyThread myThread = new MyThread();
MyThread myThread2 = new MyThread();
Thread t1 = new Thread(myThread, "t1");
t1.start();
processThread(myThread2);*/
//不同对象:class,class //不能并发
/*MyThread myThread = new MyThread();
MyThread myThread2 = new MyThread();
Thread t1 = new Thread(myThread, "t1");
t1.start();
processThread(myThread2);*/
}
public static void processThread(MyThread thread) {
thread.run2();
}
}
class MyThread implements Runnable {
@Override
public void run() {
synchronized(MyThread.class) {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
for(int i=0;i<50;i++)
System.out.println("Thread "+Thread.currentThread().getName()+" "+i+" is running");
}
}
public void run2() {
synchronized(MyThread.class) {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
for(int i=0;i<50;i++)
System.out.println("Thread "+Thread.currentThread().getName()+" "+i+" is running in run2");
}
}
}
分享到：
相关推荐
在 Java 中，synchronized 关键字可以作用于 instance 变量、object reference（对象引用）、static 函数和 class literals（类名称字面常量）身上。 Synchronized 关键字的作用是取得对象的锁，而不是把一段代码或...
synchronized (this) { // ... } } } ``` 在上面的例子中，synchronized 关键字被用于代码块中，以实现对当前对象的互斥访问控制。 三、synchronized 关键字的继承 synchronized 关键字不能被继承，即基类的 ...
本文将深入探讨`synchronized`的几种使用示例，包括方法加锁、代码块加锁（针对`this`和对象）以及静态方法加锁。 1. **方法加锁** 当在实例方法前使用`synchronized`关键字时，它会锁定当前对象的监视器，只有...
- 如果一个线程正在访问对象的`synchronized(this)`同步代码块，其他线程仍然可以访问该对象的非`synchronized(this)`代码块。例如： ```java package ts; public class Thread2 { public void m4t1() { ...
synchronized (this) { balance += amount; } } public void withdraw(double amount) { synchronized (this) { if (balance >= amount) { balance -= amount; } else { System.out.println(...
synchronized (this) { // 代码块 } } ``` 在上述案例中，`this`表示当前对象实例，也可以替换为其他对象实例，实现对特定对象的同步。 三、同步多个对象 在多对象同步中，可以通过锁定不同的对象实例来实现对...
synchronized (this) { for (int i = 0; i ; i++) { System.out.println(Thread.currentThread().getName() + " synchronized loop " + i); } } } public static void main(String[] args) { Thread1 t1 = ...
以下是一个具体的示例程序，用于演示多个线程访问同一个对象的`synchronized(this)`同步代码块时的行为。 ```java package threads; public class Thread1 implements Runnable { public void run() { ...
synchronized (this) { count++; } } // 使用自定义锁 private final Object lock = new Object(); public void incrementWithCustomLock() { synchronized (lock) { count++; } } } ``` #### 性能...
在方法级别，锁是`this`或`static`方法所属的Class对象；在同步块中，锁是块内指定的对象。同时，应该谨慎使用`synchronized`，因为它会引入性能开销，并可能导致死锁。避免不必要的同步控制，只在绝对必要的地方...
这意味着在任意时刻，都只有一个线程可以访问该实例的所有`synchronized`方法，或者进入由`synchronized(this)`标记的代码块。对于静态方法，锁对象则是该类的Class对象。 ```java public class MyClass { private...
同步方法会隐式地使用`this`作为监视器对象，或者对于静态方法，监视器对象是对应的类的Class实例。 3. **监视器对象**： - 监视器对象是用于锁定的目标，可以是任何对象。在同步代码块中，可以自定义对象作为...
- 如果一个线程在一个对象的`synchronized(this)`块中，其他线程仍然可以访问该对象的非`synchronized(this)`代码块。 - 对象锁仅适用于该对象的`synchronized`代码块，不影响其他线程对其他对象的访问。 以下是...
public class CounterThread extends Thread { private int id; public CounterThread(int id) { this.id = id; } @Override public void run() { // 获取当前线程的计数器 Integer counter = ...
用法是：synchronized(this){/*区块*/}，它的作用域是当前对象。 synchronized 的使用注意事项 1. synchronized 方法可能会对系统性能产生影响， nên尽量避免无谓的同步掌握。 2. 使用 synchronized 关键字时，...
synchronized (this) { // ... } } } ``` 在这里，`this`代表调用方法的对象，即锁是对象实例本身。 2. **同步块（同步代码块）**： 同步块允许我们指定一个具体的对象作为锁。这可以更细粒度地控制同步，...
在提供的示例中，`MyRunable`类的`run()`方法使用`synchronized(this)`代码块，这里的`this`指的是`MyRunable`对象。由于`t1`和`t2`都基于同一个`Runnable`对象`demo`创建，所以它们共享`demo`的锁。当一个线程执行`...
synchronized() 中是锁住的对象，synchronized(this) 锁住的只是对象本身，同一个类的不同对象调用这个方法并不会被锁住，而 synchronized(className.class) 实现了全局锁的功能，全部这个类的对象调用这个方法都受...