java多线程笔记

yield：线程礼让，会将线程从运行态转变为就绪态，不一定成功。注意与sleep的区别，sleep会将线程置为阻塞态，时间到了才变为就绪态，而且一定成功。

lambda表达式：格式为

(参数)->{函数体}

作用：lambda表达式是一个匿名函数，可以极大的缩减代码量，可以生成一个函数式接口（只有一个方法的接口）的对象。

join：插队，正在运行的线程让出对cpu的使用权，让另一个线程先执行，该线程执行完毕才会轮到其他线程。

守护线程：一个不怎么重要的线程，当所有用户线程执行完毕时会被强制终止。可以通过setdaemon（true）将一个线程设置为守护线程。

synchronize:可以修饰方法和块，修饰方法的话默认以this为锁，修饰块的话可以以任何对象为锁，锁的对象称为同步监视器。建议以共享资源为同步监视器。

package Com;
class Lock implements Runnable{
    Integer cnt=1;
    @Override
    public void run() {
        synchronized (cnt){//同步块实现线程安全，cnt为同步监视器
            if(cnt>=1)
            {
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(--cnt);
            }
        }

    }
}
public class TestLock {
    public static void main(String[] args) {
        Lock loc=new Lock();
        new Thread(loc).start();
        new Thread(loc).start();
    }
}

可重入锁

package Com;

import java.util.concurrent.locks.ReentrantLock;

class Lock implements Runnable{
    Integer cnt=1;
    ReentrantLock lock=new ReentrantLock();
    @Override
    public void run() {
        try{
            lock.lock();
            if(cnt>=1)
            {
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(--cnt);
            }
        }finally {
            lock.unlock();
        }
    }
}
public class TestLock {
    public static void main(String[] args) {
        Lock loc=new Lock();
        new Thread(loc).start();
        new Thread(loc).start();
    }
}

生产者消费者问题
解决方式一：利用缓冲区区解决–管程法
注意synchronized锁哪个对象就调用哪个对象的notify和wait方法

package Com.TestPc;

public class TestPc {
    public static void main(String[] args) {
        Buffer buffer=new Buffer(10);
        new Producer(buffer).start();
        new Consumer(buffer).start();
    }
}
//消费者
class Producer extends Thread{
    Buffer buffer;
    public void run(){
        for (int i = 0; i < 100; i++) {
            Production production=new Production(i);
            System.out.println("生产了第"+i+"个产品");
            synchronized (buffer){
                while(buffer.cnt==buffer.productions.length){//如果缓冲区满了会一直阻塞，直到将产品放入缓冲区
                    try {
                        buffer.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                buffer.productions[buffer.cnt++]=production;
                buffer.notifyAll();//通知消费者消费
            }

        }
    }
    public Producer(Buffer buffer){
        this.buffer=buffer;
    }
}
//生产者
class Consumer extends Thread{
    Buffer buffer;
    public void run(){
        for (int i = 0; i < 100; i++) {
            synchronized (buffer){
                while(buffer.cnt==0){
                    try {
                        buffer.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                Production production=buffer.productions[--buffer.cnt];
                System.out.println("消费了第"+production.id+"个产品");
                buffer.notifyAll();//通知生产者生产
            }

        }
    }
    public Consumer(Buffer buffer){
        this.buffer=buffer;
    }
}
//缓冲区
class Buffer{
    int cnt=0;
    Production [] productions;
    Buffer(int siz){
        productions=new Production[siz];
    }
}
class Production{
    int id;
    public Production(int id) {
        this.id = id;
    }
}

解决方式二：信号灯法

线程池：executorservice为线程池的接口 ， executors为线程池的工程类，用于创建线程池。execute和submit都用来执行任务，不同的是execute无返回值，而submit有。

package Com.ThreadPool;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class ThreadPool {
    public static void main(String[] args) {
        //创建线程池，参数为线程池大小
        ExecutorService executorService= Executors.newFixedThreadPool(10);
        //提交任务
        executorService.submit(()-> System.out.println("this is task"));
        //关闭线程池
        executorService.shutdownNow();
    }
}