Java 内部类，多线程中Synchronized与wait,notify的使用

工作内容：

1.成员内部类    与成员方法，属性的访问权限一致

2.静态内部类    修饰符 stactic 类名{...}

3.匿名内部类    new 类名()/接口名(重写接口方法)

4.局部内部类    代码块中

5.线程Thread wait,notify

学习分享：

谁去调用notify（），就解开谁，如果有多线程正在等待这个Object，则随机执行一个线程

1）调用某个对象的wait()方法能让当前线程阻塞，并且当前线程必须拥有此对象的monitor（即锁）

2）调用某个对象的notify()方法能够唤醒一个正在等待这个对象的monitor的线程，如果有多个线程都在等待这个对象的monitor，则只能唤醒其中一个线程；

3）调用notifyAll()方法能够唤醒所有正在等待这个对象的monitor的线程；

4) wait()和notifyAll()都应该放于synchorized同步代码块中

注意：notify()和notifyAll()方法只是唤醒等待该对象的monitor的线程，并不决定哪个线程能够获取到monitor。

内部类实例：

public class Demo {

public static void main(String[] args) {

OuterClass out  = new OuterClass();

//成员内部类

out.new People1().speak("传递String");

//out.new People1().show();

//静态内部类

//OuterClass.PeopleStatic.show();

}

}

public class OuterClass {

public static void main(String[] args) {

//测试同一个类中

OuterClass outer = new OuterClass();

//私有内部类的使用

outer.getPeople().show();

new OuterClass(). new People().show();

//成员内部类的使用

OuterClass.People1 people1 = outer.new People1();

people1.speak("传递String");

//静态内部类

int z = OuterClass.PeopleStatic.speak(3,5);

System.out.println(z);

}

//私有内部类

private class People{

public void show(){

System.out.println("成员内部类");

}

}

public People getPeople(){

return new People();

}

public void getInstance(){

new People().show();

}

//成员内部类

String string = "外部类string";

class People1{

String string = "内部类string";

public void speak(String string){

System.out.println(string);//传递的string

System.out.println(this.string);//内部类的string

System.out.println(OuterClass.this.string);//外部类string

}

private void show(){

System.out.println("成员内部类show");

}

}

//静态内部类

private static class PeopleStatic{

/**

 * 静态内部类的方法需在外面打点调用，则方法必须是静态方法

 * 静态内部类的方法需在外面生成对象，可以对象打点调用非private ,static修饰的方法

 * @param x

 * @param y

 * @return

 */

private static int  speak(int x,int y){

return x*y;

}

public static void show(){

System.out.println("静态内部类 静态方法show");

}

}

}

实例2：

//测试synchronized(obj){}中wait和notify的使用

public class StaticObjectTestLock {
public static Object a = new Object();
public static Object b = new Object();
public static Object c = new Object();
public static Object d = new Object();
static int x=6;
public static void main(String[] args) throws InterruptedException {
new LockObj(1).start();
//调用sleep保证其顺序执行
Thread.sleep(500);
new LockObj(3).start();
Thread.sleep(500);
new LockObj(2).start();
Thread.sleep(500);
new LockObj(4).start();
}
}
class LockObj extends Thread{
public int x;
public LockObj(int x) {
this.x = x ;
}
@Override
public void run() {
if(this.x == 1){
while (x<10) {
x++;
synchronized(StaticObjectTestLock.a){
System.out.println("A运行A wait");
try {
StaticObjectTestLock.a.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
if(this.x == 2){
while (x<10) {
x++;
synchronized(StaticObjectTestLock.b){
System.out.println("B运行，解开C");
synchronized(StaticObjectTestLock.c){
StaticObjectTestLock.c.notify();
// System.out.println("1111");
}
try {
StaticObjectTestLock.b.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
if(this.x ==3){
while (x<10) {
x++;
synchronized(StaticObjectTestLock.c){
System.out.println("C运行C wait");
synchronized (StaticObjectTestLock.a) {
// System.out.println("申请成功,C wait");
}
try {
StaticObjectTestLock.c.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
if(this.x ==4){
while (x<10) {
x++;
synchronized(StaticObjectTestLock.d){
System.out.println("D运行,解开C");
synchronized (StaticObjectTestLock.c) {
// System.out.println("解开C, D wait");
StaticObjectTestLock.c.notify();
}
try {
StaticObjectTestLock.d.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
}
}