非线程安全问题
“非线程安全”问题存在于“实例变量”中，如果是方法内部的私有变量，则不存在“非线程问题”。也即是说，方法中的变量永远是线程安全的。
如果多个线程共同访问1个对象中的实例变量，则可能线程不安全。下面以实例说明
public class HasSelfNum {
private int num = 0;
public void add(String name) {
try {
if (name.equals("a")) {
num = 100;
System.out.println("a over");
Thread.sleep(1000);
} else {
num = 200;
System.out.println("b over");
}
System.out.println(name+" "+num);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
public class ThreadA extends Thread{
private HasSelfNum hasSelfNum;
public ThreadA(HasSelfNum hasSelfNum) {
this.hasSelfNum = hasSelfNum;
}
@Override
public void run() {
super.run();
hasSelfNum.add("a");
}
}
public class ThreadB extends Thread{
private HasSelfNum hasSelfNum;
public ThreadB(HasSelfNum hasSelfNum) {
this.hasSelfNum = hasSelfNum;
}
@Override
public void run() {
super.run();
hasSelfNum.add("b");
}
}
public class Main {
public static void main(String[] args) {
HasSelfNum hasSelfNum = new HasSelfNum();
ThreadA threadA = new ThreadA(hasSelfNum);
ThreadB threadB = new ThreadB(hasSelfNum);
threadA.start();
threadB.start();
}
}
Result
a over
b over
b 200
a 200
非线程安全！
如何处理？
在add方法上加上关键字 synchronized
synchronized public void add(String name)
Result
a over
a 100
b over
b 200
线程安全，同步访问add()方法
如果是多个对象的情况？
将上面的Main.java进行修改
public class Main {
public static void main(String[] args) {
HasSelfNum hasSelfNum = new HasSelfNum();
HasSelfNum hasSelfNum2 = new HasSelfNum(); //两个对象
ThreadA threadA = new ThreadA(hasSelfNum);
ThreadB threadB = new ThreadB(hasSelfNum2);
threadA.start();
threadB.start();
}
}
Result
a over
b over
b 200
a 100
两个线程分别访问同一个类的不同实例的相同同步方法，产生了两个锁，运行的结果是异步的。
由此可以看出，关键字synchronized取得的锁是对象锁
若类中既有synchronized类型方法又有非synchronized类型方法
public class MyObject {
synchronized public void methodA(){
try {
System.out.println(Thread.currentThread().getName()+" begin");
Thread.sleep(1000);
System.out.println(Thread.currentThread().getName()+" end");
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
public void methodB(){
try {
System.out.println(Thread.currentThread().getName()+" begin");
Thread.sleep(1000);
System.out.println(Thread.currentThread().getName()+" end");
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
public class ThreadA extends Thread{
MyObject myObject;
public ThreadA(MyObject myObject) {
this.myObject = myObject;
}
@Override
public void run() {
super.run();
myObject.methodA();
}
}
public class ThreadB extends Thread{
MyObject myObject;
public ThreadB(MyObject myObject) {
this.myObject = myObject;
}
@Override
public void run() {
super.run();
myObject.methodB();
}
}
public class Main {
public static void main(String[] args) {
MyObject myObject = new MyObject();
ThreadA threadA = new ThreadA(myObject);
ThreadB threadB = new ThreadB(myObject);
threadA.setName("A");
threadB.setName("B");
threadA.start();
threadB.start();
}
}
Result
A begin
B begin
B end
A end
线程A持有myObject对象锁，但线程B仍可以异步调用非synchronized类型方法
当在methodB方法前也加上synchronized关键字时
Result
A begin
A end
B begin
B end
线程A、B以同步的方式执行对象中的两方法
synchronized同步代码块
当synchronized修饰的方法里有个耗时很长的代码时，效率是很低的。同步代码块分为：
1.synchronized(this)
在方法中不在同步代码块中的代码异步执行，而在其中的代码同步执行
同个对象中的synchronized(this)使用的对象监视器是同一个，也就是说，当一个线程访问某个synchronized(this)代码块里面的方法时，其他线程访问其他synchronized(this)块里面的方法是会被阻塞的。另外synchronized(this)使用的监视器和syncheronized 修饰方法一致是当前对象，也会阻塞synchronized修饰的方法。
2.synchronized(obj) 非this
多个线程同时访问时只能阻塞synchronized(obj)的代码块。
同时如果锁是同一个myObject对象，还是会阻塞的
public class MyObject {
synchronized public void methodA() {
try {
System.out.println(Thread.currentThread().getName() + " begin");
Thread.sleep(1000);
System.out.println(Thread.currentThread().getName() + " end");
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
public void methodB(MyObject myObject) {
synchronized (myObject) {
try {
System.out.println(Thread.currentThread().getName() + " begin");
Thread.sleep(1000);
System.out.println(Thread.currentThread().getName() + " end");
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}
public class ThreadA extends Thread{
MyObject myObject;
public ThreadA(MyObject myObject) {
this.myObject = myObject;
}
@Override
public void run() {
super.run();
myObject.methodA();
}
}
public class ThreadB extends Thread{
MyObject myObject;
public ThreadB(MyObject myObject) {
this.myObject = myObject;
}
@Override
public void run() {
super.run();
myObject.methodB(myObject);
}
}
public class Main {
public static void main(String[] args) {
MyObject myObject = new MyObject();
ThreadA threadA = new ThreadA(myObject);
ThreadB threadB = new ThreadB(myObject);
threadA.setName("A");
threadB.setName("B");
threadB.start();
threadA.start();
}
}
Result
B begin
B end
A begin
A end
《Java多线程编程核心技术》学习