最近看了些关于多线程的文章，感觉还没有很深刻地理解，决定自己动手写几个例子来测试一下，加深对多线程的理解。
基础入门：Java的锁是针对某个对象或者某个类，即是对象锁和类锁。
对象锁：1.非静态的同步方法. 2.synchronized(object) 3. synchronized(this)
类锁： 1.静态的同步方法(static synchronized) . 2. synchronized(XXX.class)
需要注意的点：
1.非静态的同步方法 和 synchronized(this) 是等效的，调用该方法的对象会被作为锁，直到该同步方法执行完成。同步代码块比直接在方法上使用synchronized的性能更好。
2.静态的同步方法(static synchronized) 是以该方法所在的类作为锁。synchronized(XXX.class)是以XXX.class作为锁，当XXX.class 和 静态同步方法所在的类是同一个类时，两者是等效的。
public class ThreadModel {
public static synchronized void doBackGroundClass(int count) {
for (int i = 0; i < count; i++) {
try {
Thread.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println("doBackGroundClass -------> " + count + " 执行完毕");
}
public synchronized void doBackGround(int count) {
for (int i = 0; i < count; i++) {
try {
Thread.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println("doBackGround -------> " + count + " 执行完毕");
}
}
创建一个ThreadModel类，里面分别有两个方法，一个是静态同步方法doBackGroundClass，另一个是非静态的同步方法doBackGround
public static void main(String[] args) {
new Thread() {
@Override
public void run() {
//类锁
ThreadModel.doBackGroundClass(1000);
}
}.start();
new Thread() {
@Override
public void run() {
//对象锁
ThreadModel threadModel = new ThreadModel();
threadModel.doBackGround(10);
}
}.start();
}
执行结果如下
doBackGround -------> 10 执行完毕
doBackGroundClass -------> 1000 执行完毕
结果分析：静态同步方法和非静态同步方法之间并不会完成同步，因为两者的锁并非同一把锁，一个是以ThreadModel.class作为锁，另一个是以new ThreadModel()对象作为锁，不同的锁之间不能完成同步。
public static void main(String[] args) {
new Thread() {
@Override
public void run() {
//类锁
ThreadModel.doBackGroundClass(1000);
}
}.start();
new Thread() {
@Override
public void run() {
ThreadModel.doBackGroundClass(10);
//对象锁
// ThreadModel threadModel = new ThreadModel();
// threadModel.doBackGround(10);
}
}.start();
}
执行结果如下
doBackGroundClass -------> 1000 执行完毕
doBackGroundClass -------> 10 执行完毕
结果分析：ThreadModel类的静态同步方法都是共用ThreadModel.class作为锁，所以Java类的中的所有静态同步方法之间都是会完成同步的。
public static void main(String[] args) {
new Thread() {
@Override
public void run() {
ThreadModel threadModel = new ThreadModel();
threadModel.doBackGround(1000);
//类锁
// ThreadModel.doBackGroundClass(1000);
}
}.start();
new Thread() {
@Override
public void run() {
// ThreadModel.doBackGroundClass(10);
//对象锁
ThreadModel threadModel2 = new ThreadModel();
threadModel2.doBackGround(10);
}
}.start();
}
执行结果
doBackGround -------> 10 执行完毕
doBackGround -------> 1000 执行完毕
结果分析：threadModel 和 threadModel2 在内存中是完全两个不同的对象，不同的对象锁之间是不会完成同步的。
public static void main(String[] args) {
ThreadModel threadModel = new ThreadModel();
new Thread() {
@Override
public void run() {
//对象锁
threadModel.doBackGround(1000);
//类锁
// ThreadModel.doBackGroundClass(1000);
}
}.start();
new Thread() {
@Override
public void run() {
// ThreadModel.doBackGroundClass(10);
//对象锁
threadModel.doBackGround(10);
}
}.start();
}
执行结果
doBackGround -------> 1000 执行完毕
doBackGround -------> 10 执行完毕
结果分析：同一个对象锁会产生互斥，完成同步
思考题：
修改代码如下
public static synchronized void doBackGroundClass(int count) {
new Thread() {
@Override
public void run() {
for (int i = 0; i < count; i++) {
try {
Thread.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println("doBackGroundClass -------> " + count + " 执行完毕");
}
}.start();
}
public synchronized void doBackGround(int count) {
new Thread() {
@Override
public void run() {
for (int i = 0; i < count; i++) {
try {
Thread.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println("doBackGround -------> " + count + " 执行完毕");
}
}.start();
}
public static void main(String[] args) {
ThreadModel threadModel = new ThreadModel();
threadModel.doBackGround(1000);
threadModel.doBackGround(10);
}
}
如果程序这样执行，能同步吗？
doBackGround -------> 10 执行完毕
doBackGround -------> 1000 执行完毕
答案是不能！因为这样写已经不存在多线程同步问题了，doBackGround(1000)和.doBackGround(10) 都是在主线程里执行的，他们是顺序执行的。在方法内部，又开启了一个新的线程，所以产生了异步，10比1000先执行完成 。