多线程并发

创建

• 继承Thread类
• 实现Runnable接口

启动

• start()

线程池

    //创建线程池对象
    ExecutorService pool = poolecutors.newFixedThreadPool(2);
  
    MyRun myRun = new MyRun();
  
    pool.submit(myRun);
   
    pool.submit(myRun);
    
    pool.shutdown();

同步

```
public synchronized void method() {
    可能会产生线程安全问题的代码
}
```

死锁

```
synchronized(A锁){
    synchronized(B锁){
    
    }
}
```

Lock 接口

• void lock()：获得锁
• void unlock()：释放锁

等待和唤醒

• wait()：等待。将正在执行的线程释放其执行资格和执行权，并存储到线程池中
• notify()：唤醒。唤醒线程池中被 wait() 的线程，一次唤醒一个，而且是任意的
• notifyAll()：唤醒全部。可以将线程池中的所有 wati() 线程都唤醒

新建线程

继承Thread

class MyThread extends Thread{
    
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            print(currentThread().getName()+" : "+i);
        }
    }

    static void print(Object... obj){
        for (Object o:obj) {
            System.out.println(o.toString());
        }
    }
}

实现Runnable接口

Thread th=new Thread(new Runnable() {
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println(currentThread().getName()+" : "+i);
        }
    }
});
th.start();

最简写法

new Thread(()-> {
                for (int i = 0; i < 10; i++) {
                    System.out.println(currentThread().getName()+" : "+i);
                }
        }).start();

常用方法

1. sleep(long millis) 在指定的毫秒数内让当前正在执行的线程休眠（暂停执行）
2. join() 等待此线程(子线程)执行完毕。
3. yield() 让步到Runnable状态，允许具有相同优先级的其他线程获得运行机会(依赖操作系统,不建议使用!!!)。
4. setPriority() 更改线程的优先级(依赖操作系统,不建议使用!!!)。
5. interrupt()它不能中断某个线程！它只是线线程发送一个中断信号，让线程在无限等待时（如死锁时）能抛出抛出，从而结束线程，但是如果你吃掉了这个异常，那么这个线程还是不会中断的！
6. wait()&notify()属于Object类,配合使用控制线程同步

线程同步

public class SynThread {
    public static void main(String[] args) throws Exception {

        Object a=new Object();
        Object b=new Object();
        Object c=new Object();

        MyRunnable ra=new MyRunnable("A",c,a);
        MyRunnable rb=new MyRunnable("B",a,b);
        MyRunnable rc=new MyRunnable("C",b,c);

        new Thread(ra).start();
        Thread.sleep(1000);

        new Thread(rb).start();
        Thread.sleep(1000);

        new Thread(rc).start();
        Thread.sleep(1000);

    }
}

class MyRunnable implements Runnable{

    private String name;
    private Object prev;
    private Object self;

    public MyRunnable(String name, Object prev, Object self) {
        this.name = name;
        this.prev = prev;
        this.self = self;
    }

    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {

            synchronized(prev){
                synchronized(self){
                    System.out.println(name);
                    self.notify();
                }
                try {
                    prev.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}