2021年3月2日20点21分
JAVA自学课程笔记8：
synchronized（同步）修饰代码块：
格式：
synchronized(object aa){
//同步代码块
}
含义:判断aa是否已经被其他线程霸占（术语：锁定），如果发现已经被其他线程霸占。则当前线程陷入等待中，如果发现aa没有被其他线程霸占，则当前线程霸占在aa对象，并执行语句内的同步代码块在当前线程执行同步代码块代码时，其他线程将无法再执行同步代码块的代码（因为当前线程已经霸占了aa对象），当前线程执行完同步代码块的代码后，会自动释放对aa对象的霸占，此时其他线程会相互竞争对aa的霸占，最终CPU会选择其中的某个线程执行。霸占住的那个对象术语叫：监听器。
最终导致的结果是:一个线程正在操作某资源的时候，将不允许其它线程操作该资源，即一次只允许一个线程处理该资源。
火车买票程序：
Test1:
class A implements Runnable{
public static int tickets = 100;
public void run(){
while(true){
if(tickets > 0){
System.out.printf("%s线程正在卖出第%d张票", Thread.currentThread().getName(), tickets);
tickets --;
}else{
break;
}
}
}
}
public class Test1{
public static void main(String[] args){
A aa1 = new A();
Thread t1 = new Thread(aa1);
t1.start();
A aa2 = new A();
Thread t2 = new Thread(aa2);
t2.start();
}
}
//虽然用的是static修饰的tickets，但是还是会在执行语句时发生落差，一个对象在不同线程被同时执行且产生时间差，例如1号线程在卖第99张票时，2号线程已经在卖第94张票了，假如正好下一次轮到了1号线程卖，就卖到了第93张。同一个对象被两个线程同时占用，应发程序bug。
Test2:
class A implements Runnable{
public static int tickets = 100;
String str = new String("我是一个字符对象!");
public void run(){
while(true){
synchronized(str){
if(tickets > 0){
System.out.printf("%s线程正在卖出第%d张票\n", Thread.currentThread().getName(), tickets);
tickets --;
}else{
break;
}
}
}
}
}
public class Test2{
public static void main(String[] args){
A aa = new A();
Thread t1 = new Thread(aa);
t1.start();
Thread t2 = new Thread(aa);
t2.start();
}
}
synchronized修饰一个方法时，实际霸占的是该方法的this指针所指的对象（即synchronized修饰一个方法时，实际霸占的是正在调用该方法的对象）当一个线程进入这个方法后，这个方法的大门就会暂时关闭(不许其他线程进入)直到这个线程走出这个方法后,该方法的大门才会敞开。当然，这个关闭只是对于该类的当前实例有效，多个实例的对象仍然可以同时执行。若Test2的run()方法用synchronized修饰，运行结果会是永远只有一个线程在卖票。
生产和消费程序：
class SynStack{
private int cnt = 0;
private char[] data = new char[6];
public synchronized void push(char c){
while(cnt==data.length){
try{
this.wait();
}catch(InterruptedException e){}
}
this.notify();
data[cnt] = c;
cnt++;
System.out.println("produced #: "+c);
}
public synchronized char pop(){
char c;
while(cnt==0){
try{
this.wait();
}catch(InterruptedException e){}
}
this.notify();
cnt--;
System.out.println("consumed *: "+data[cnt]);
return data[cnt];
}
}
class Producer implements Runnable{
private SynStack ss = null;
public Producer(SynStack ss){
this.ss = ss;
}
public void run(){
char c;
for(int i=0; i<20; ++i){
c = (char)('1'+i);
ss.push(c);
}
}
}
class Consumer implements Runnable{
private SynStack ss = null;
public Consumer(SynStack ss){
this.ss = ss;
}
public void run(){
for(int i=0; i<20; ++i){
try{
Thread.sleep(2000);
}catch(InterruptedException e){}
ss.pop();
}
}
}
public class test1{
public static void main(String[] args){
SynStack ss = new SynStack();
Producer p = new Producer(ss);
Consumer c = new Consumer(ss);
Thread t1 = new Thread(p);
t1.start();
Thread t2 = new Thread(c);
t2.start();
}
}
//满足一个线程消费，另外一个线程生产且具有同步性。
