JAVA(8)多线程

方法1实现runnable接口
方法2实现Thread接口

public class CreateThread implements Runnable {
    void run(){

    }
}

匿名类
没有构造函数

Class A{
    int i;
    A(int j){i=j;}
    public static void main(String[] args){
        A a=new A(0);
        A b=new A(5){
            //初始化代码，充当构造函数
        }
        A c=new K(){}//K是抽象的接口，调用Object的构造函数
    }
}

new A(0){public void a(){}}.a();

Class A{
    int i;
    Class B{//该类的定义依赖与A类的对象
        int i;
        public void a(int k){
            i=k;//访问B的i.
            A.this.i..;
            B.this.i..;
        }
    }
}

同步互斥

synchronized关键字可以修饰函数或代码段
执行同步对象之前必须抢到对象锁，执行完后释放锁

解决冲突1：加锁
解决冲突2：数据复制

//synchronized可能会引起死锁
//synchronized(lock)可以定义多个锁并且传进去。

private lock1 = new byte[0];

一个线程持有对象锁才能调用对象的wait函数

//执行wait函数时，线程就如同死掉一样。没有办法继续往下执行
try {
    wait();
}
catch(e){
    e.printStackTrace();
}

sleep()释放Cpu不会释放对象锁;
wait();会释放对象锁:不占用CPU也不占用对象锁
notify();

synchronized public char pop(){
    while(index==0){
        try{
            wait();
        }
        catch(InterruptedException e){
            e.printStackTrace();
        }
    }
    index--;
    notifyAll();
    return data[index];
}

两把对象锁。进入锁的顺序应该是一致的。否则就会产生死锁。

volatile
临界变量。用来修饰变量。如果只有少量变量为临界变量，则可以用volatile来形容。