Java多线程

根据blibli狂神说java以及
https://www.cnblogs.com/jiawen010/p/11855768.html编写

实现多线程的方法

1.重写Thread类的run()方法
2.实现Runable接口的rum方法，再Thread(runable)

静态代理模式(不需要掌握)

package 静态代理;

public class Demo {

    public static void main(String[] args) {
            WeddingCompany weddingCompany=new WeddingCompany(new You());
            weddingCompany.HappyMerry();
    }
    interface Merry{
        void HappyMerry();
    }
    //真实对象
    static class You implements Merry{

        @Override
        public void HappyMerry() {
            System.out.println("章老师要结婚了，超开心");
        }
    }
    //代理对象(帮助你结婚)
    static class WeddingCompany implements Merry{
        private You you;
        WeddingCompany(You you){
            this.you=you;
        }
        @Override
        public void HappyMerry() {
            before();
            you.HappyMerry();
            after();
        }

        private void after() {
            System.out.println("婚前现场布置...");
        }

        private void before() {
            System.out.println("婚后结尾款...");
        }
    }
}

线程的5种状态

实现同步的方法:synchronized，Lock，volatile的区别

volatile只能修饰变量，保证的变量的可见性，有序性，无法保证原子性。如果一个共享变量被volatile关键字修饰，那么如果一个线程修改了这个共享变量后，其他线程是立马可知的。但是无法保证原子性
详情请看:
https://www.cnblogs.com/xd502djj/p/9873067.html
synchronized可以用在变量、方法、类、同步代码块等，用于锁住资源，其他线程要是想调用该资源，需要等待。重量级操作，效率较低
Lock是一个接口，ReentrantLock是它的实现类，调用lock.lock()锁住资源，lock.unlock()解锁资源，效率较高

sleep()和wait()的区别

sleep让线程休眠，但是资源还是锁住的，它是Thread的静态方法
wait()用于线程间通信，是Object里的静态方法，使用后会释放资源，是线程进入等待线程队列，当调用notify()/notifyall()时，才会从等待队列唤醒该线程。

其他方法

join()，阻塞当前线程，加入另一个线程，知道另一个线程结束，才会启动阻塞的线程
yield()，线程礼让，该方法与sleep()类似，只是不能由用户指定暂停多长时间。不会释放锁。

生产者和消费者问题

当出现A要生产，B要消费。他们有一个共享资源区，如果都占用该资源区就会出现死锁，这个时候可以使用wait()方法，具体是在生产完以后使用wait()释放资源，然后消费完以后，调用notify()。

线程池

为什么要有线程池

1.创建/销毁线程伴随着系统开销，过于频繁的创建/销毁线程，会很大程度上影响处理效率
2.线程能共享系统资源，如果同时执行的线程过多，就有可能导致系统资源不足而产生阻塞
3.对线程进行一些简单的管理
比如：延时执行、定时循环执行的策略等

线程池的使用

 //创建线程池
        ExecutorService service= Executors.newFixedThreadPool(10);

源码

    public static ExecutorService newFixedThreadPool(int nThreads) {
        return new ThreadPoolExecutor(nThreads, nThreads,
                                      0L, TimeUnit.MILLISECONDS,
                                      new LinkedBlockingQueue<Runnable>());
    }

corePoolSize：最小活动线程数量
maximumPoolSize：最大线程数量
workQueue:该线程池中的任务队列：维护着等待执行的 Runnable 对象。当所有的核心线程都在干活时，新添加的任务会被添加到这个队列中等待处理，如果队列满了，则新建非核心线程执行任务

四种线程池

1.newCachedThreadPool
可缓存线程池，先查看池中有没有以前建立的线程，如果有，就直接使用。如果没有，就建一个新的线程加入池中，缓存型池子通常用于执行一些生存期很短的异步型任务

package 线程池;

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

/**
 * 描述: 创建一个可缓存的线程池。如果线程池的大小超过了处理任务所需要的线程，那么就会回收部分空闲（60秒不执行任务）的线程，当任务数增加时，此线程池又可以智能的添加新线程来处理任务。
 * 此线程池不会对线程池大小做限制，线程池大小完全依赖于操作系统（或者说JVM）能够创建的最大线程大小。

 **/
public class TestNewCachedThreadPool {
    public static void main(String[] args) {
        ExecutorService cachedThreadPool = Executors.newCachedThreadPool();
        for (int i = 1; i <= 10; i++) {
            final int index = i;
            try {
                Thread.sleep(index * 1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            cachedThreadPool.execute(new Runnable() {

                @Override
                public void run() {
                    String threadName = Thread.currentThread().getName();
                    System.out.println("执行：" + index + "，线程名称：" + threadName);
                }
            });
        }
    }
}

2.newFixedThreadPool
创建一个可重用固定个数的线程池，以共享的无界队列方式来运行这些线程。

package 线程池;

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

public class NewFixedThreadPoolTest {

    public static void main(String[] args) {
        // 创建一个可重用固定个数的线程池
        ExecutorService fixedThreadPool = Executors.newFixedThreadPool(3);
        for (int i = 0; i < 10; i++) {
            fixedThreadPool.execute(new Runnable() {
                public void run() {
                    try {
                        // 打印正在执行的缓存线程信息
                        System.out.println(Thread.currentThread().getName()
                                + "正在被执行");
                        Thread.sleep(2000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            });
        }
    }

}

3.newScheduledThreadPool
创建一个定长线程池，支持定时及周期性任务执行

package 线程池;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

public class NewScheduledThreadPoolTest {

    public static void main(String[] args) {
        //创建一个定长线程池，支持定时及周期性任务执行——延迟执行
        ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(5);
        //延迟1秒执行
                 /*scheduledThreadPool.schedule(new Runnable() {
                     public void run() {
                        System.out.println("延迟1秒执行");
                     }
                 }, 1, TimeUnit.SECONDS);*/


        //延迟1秒后每3秒执行一次
        scheduledThreadPool.scheduleAtFixedRate(new Runnable() {
            public void run() {
                System.out.println("延迟1秒后每3秒执行一次");
            }
        }, 1, 3, TimeUnit.SECONDS);

    }

}

4.newSingleThreadExecutor
创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。

package 线程池;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class NewSingleThreadExecutorTest {


    public static void main(String[] args) {
        //创建一个单线程化的线程池
        ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor();
        for (int i = 0; i < 10; i++) {
            final int index = i;
            singleThreadExecutor.execute(new Runnable() {
                public void run() {
                    try {
                        //结果依次输出，相当于顺序执行各个任务
                        System.out.println(Thread.currentThread().getName()+"正在被执行,打印的值是:"+index);
                        Thread.sleep(5000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            });
        }
    }
}