串行执行
**First?*我们来说说Stream的并行和串行。Stream中有两个函数parallel()和sequential()，分别代表了并行和串行，串行比较好理解，就是在主线程上按顺序执行逻辑代码，那么并行呢？那么我们要来说说什么是并行和并发，以前我们的CPU是单核的，多个任务是通过划分时间片轮训来执行任务，这样的逻辑叫做并发。现代的CPU的多核的，有多少个核心就可以同一时间可以运行更多的任务，所以并行和并发大家就明白了。
second:多个线程访问同一个类的synchronized方法时, 都是串行执行的 ! 就算有多个cpu也不例外 !
synchronized方法使用了类java的内置锁, 即锁住的是方法所属对象本身. 同一个锁某个时刻只能被一个执行线程所获取,
因此其他线程都得等待锁的释放. 因此就算你有多余的cpu可以执行, 但是你没有锁, 所以你还是不能进入synchronized方法执行, CPU因此而空闲.
如果某个线程长期持有一个竞争激烈的锁, 那么将导致其他线程都因等待所的释放而被挂起,
从而导致CPU无法得到利用, 系统吞吐量低下. 因此要尽量避免某个线程对锁的长期占有 !
package Demo3;
public class SyncMethod {
public synchronized void syncMethod2() {
try {
System.out.println("@@@@@@@@@@@@@@@@@@@@@@@@ (syncMethod2, 已经获取内置锁`SyncMethod.this`)");
Thread.sleep(5000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("@@@@@@@@@@@@@@@@@@@@@@@@ (syncMethod2, 即将释放内置锁`SyncMethod.this`)");
}
public synchronized void syncMethod1() {
System.out.println("######################## (syncMethod1, 已经获取内置锁`SyncMethod.this`, 并即将退出)");
}
}
```java
package Demo3;
public class Thread1 extends Thread {
SyncMethod syncMethod;
public Thread1(SyncMethod syncMethod) {
this.syncMethod = syncMethod;
}
@Override
public void run() {
syncMethod.syncMethod2();
}
}
package Demo3;
public class Thread2 extends Thread {
SyncMethod syncMethod;
public Thread2(SyncMethod syncMethod) {
this.syncMethod = syncMethod;
}
@Override
public void run() {
System.out.println("Thread2 running ...");
syncMethod.syncMethod1();
}
}
package Demo3;
public class Test2 {
public static void main(String[] args) throws InterruptedException {
SyncMethod syncMethod = new SyncMethod();
Thread1 thread1 = new Thread1(syncMethod);
Thread2 thread2 = new Thread2(syncMethod);
thread1.start(); //先执行, 以便抢占锁
Thread1.sleep(500); //放弃cpu, 让thread1执行, 以便获的锁
thread2.start(); //在syncMethod1()方法获得锁时, 看看syncMethod2()方法能否执行
// new Thread(()->{syncMethod.syncMethod2();}).start();
// new Thread(()->{syncMethod.syncMethod1();}).start();
}
}
@@@@@@@@@@@@@@@@@@@@@@@@ (syncMethod2, 已经获取内置锁`SyncMethod.this`)
Thread2 running ...
@@@@@@@@@@@@@@@@@@@@@@@@ (syncMethod2, 即将释放内置锁`SyncMethod.this`)
######################## (syncMethod1, 已经获取内置锁`SyncMethod.this`, 并即将退出)
多个线程访问同一个类的synchronized方法时, 都是串行执行的,很显然有长达5秒钟的时间空缺，另一个线程竟然没有加入，因此其他线程都得等待锁的释放.。因此就算你有多余的cpu可以执行, 但是你没有锁, 所以你还是不能进入synchronized方法执行, CPU因此而空闲。
因此是串行执行。
**
并行执行
**
package Demo3;
public class SyncMethod2 {
private Object lock1 = new Object();
private Object lock2 = new Object();
public void syncMethod2() {
synchronized (lock1) {
try {
System.out.println("@@@@@@@@@@@@@@@@@@@@@@@@ (syncMethod2, 已经获取内置锁`SyncMethod.this`)");
Thread.sleep(5000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("@@@@@@@@@@@@@@@@@@@@@@@@ (syncMethod2, 即将释放内置锁`SyncMethod.this`)");
}
}
public void syncMethod1() {
synchronized (lock2) {
System.out.println("######################## (syncMethod1, 已经获取内置锁`SyncMethod.this`, 并即将退出)");
}
}
}
package Demo3;
public class Thread21 extends Thread {
SyncMethod2 syncMethod2;
public Thread21(SyncMethod2 syncMethod2) {
this.syncMethod2 = syncMethod2;
}
@Override
public void run() {
syncMethod2.syncMethod2();
}
}
package Demo3;
public class Thread22 extends Thread {
SyncMethod2 syncMethod2;
public Thread22(SyncMethod2 syncMethod2) {
this.syncMethod2 = syncMethod2;
}
@Override
public void run() {
System.out.println("Thread22 running ...");
this.syncMethod2.syncMethod1();
}
}
package Demo3;
public class Test22 {
public static void main(String[] args) {
SyncMethod2 syncMethod2 = new SyncMethod2();
Thread21 thread21 = new Thread21(syncMethod2);
Thread22 thread22 = new Thread22(syncMethod2);
thread21.start(); //先执行, 以便抢占锁
thread22.start(); //在syncMethod1()方法获得锁时, 看看syncMethod2()方法能否执行
}
}
@@@@@@@@@@@@@@@@@@@@@@@@ (syncMethod2, 已经获取内置锁`SyncMethod.this`)
Thread22 running ...
######################## (syncMethod1, 已经获取内置锁`SyncMethod.this`, 并即将退出)
@@@@@@@@@@@@@@@@@@@@@@@@ (syncMethod2, 即将释放内置锁`SyncMethod.this`)
显然是并行执行命令。
1.Synchronized修饰非静态方法，实际上是对调用该方法的对象加锁，俗称“对象锁”。
情况1：同一个对象在两个线程中分别访问该对象的两个同步方法
结果：会产生互斥。
解释：因为锁针对的是对象，当对象调用一个synchronized方法时，其他同步方法需要等待其执行结束并释放锁后才能执行。
情况2：不同对象在两个线程中调用同一个同步方法
结果：不会产生互斥。
解释：因为是两个对象，锁针对的是对象，并不是方法，所以可以并发执行，不会互斥。形象的来说就是因为我们每个线程在调用方法的时候都是new 一个对象，那么就会出现两个空间，两把钥匙，
2.Synchronized修饰静态方法，实际上是对该类对象加锁，俗称“类锁”。
情况1：用类直接在两个线程中调用两个不同的同步方法
结果：会产生互斥。
解释：因为对静态对象加锁实际上对类（.class）加锁，类对象只有一个，可以理解为任何时候都只有一个空间，里面有N个房间，一把锁，因此房间（同步方法）之间一定是互斥的。
注：上述情况和用单例模式声明一个对象来调用非静态方法的情况是一样的，因为永远就只有这一个对象。所以访问同步方法之间一定是互斥的。
情况2：用一个类的静态对象在两个线程中调用静态方法或非静态方法
结果：会产生互斥。
解释：因为是一个对象调用，同上。
情况3：一个对象在两个线程中分别调用一个静态同步方法和一个非静态同步方法
结果：不会产生互斥。
解释：因为虽然是一个对象调用，但是两个方法的锁类型不同，调用的静态方法实际上是类对象在调用，即这两个方法产生的并不是同一个对象锁，因此不会互斥，会并发执行。