java线程有关知识点

多线程技术概述

线程与进程

进程：是指一个内存中运行的应用程序，每个进程都有一个独立的内存空间

线程：是进程中的一个执行路径，共享一个内存空间，线程之间可以自由切换，并发执行. 一个进程最少有一个线程 线程实际上是在进程基础之上的进一步划分，一个进程启动之后，里面的若干执行路径又可以划分成若干个线程。

线程的生命周期：https://www.cnblogs.com/marsitman/p/11228684.html

也就是，一个进程可以通过多个线程来执行。

线程调度

分时调度 

所有线程轮流使用 CPU 的使用权，平均分配每个线程占用 CPU 的时间。

抢占式调度

优先让优先级高的线程使用 CPU，如果线程的优先级相同，那么会随机选择一个(线程随机性)，Java使用的为抢占式调度。 

CPU使用抢占式调度模式在多个线程间进行着高速的切换。对于CPU的一个核新而言，某个时刻，只能执行一个线程，而 CPU的在多个线程间切换速度相对我们的感觉要快，看上去就是在同一时刻运行。 其实，多线程程序并不能提高程序的运行速度，但能够提高程序运行效率，让CPU的使用率更高。

同步与异步

同步:排队执行 , 效率低但是安全.

异步:同时执行 , 效率高但是数据不安全.

并发与并行

并发：指两个或多个事件在同一个时间段内发生。

并行：指两个或多个事件在同一时刻发生（同时发生）。

线程池 Executors

如果并发的线程数量很多，并且每个线程都是执行一个时间很短的任务就结束了，这样频繁创建线程就会大大降低 系统的效率，因为频繁创建线程和销毁线程需要时间. 线程池就是一个容纳多个线程的容器，池中的线程可以反复使用，省去了频繁创建线程对象的操作，节省了大量的时间和资源。

线程池的好处

降低资源消耗。

提高响应速度。

提高线程的可管理性。

Java中的四种线程池 . ExecutorService

1. 缓存线程池

/**

* 缓存线程池.

* (长度无限制)

* 执行流程:

* 1. 判断线程池是否存在空闲线程

* 2. 存在则使用

* 3. 不存在,则创建线程 并放入线程池, 然后使用

*/

ExecutorService service = Executors.newCachedThreadPool();

//向线程池中 加入 新的任务

service.execute(new Runnable() {

@Override

public void run() {

System.out.println("线程的名称:"+Thread.currentThread().getName());

}

});

service.execute(new Runnable() {

@Override

public void run() {

System.out.println("线程的名称:"+Thread.currentThread().getName());

}

});

service.execute(new Runnable() {

@Override

public void run() {

System.out.println("线程的名称:"+Thread.currentThread().getName());

}

});

说明：根据空闲来判断是否创建还是用空闲的

 

1. 定长线程池

/**

* 定长线程池.

* (长度是指定的数值)

* 执行流程:3. 单线程线程池

4. 周期性任务定长线程池

* 1. 判断线程池是否存在空闲线程

* 2. 存在则使用

* 3. 不存在空闲线程,且线程池未满的情况下,则创建线程 并放入线程池, 然后使用

* 4. 不存在空闲线程,且线程池已满的情况下,则等待线程池存在空闲线程

*/

ExecutorService service = Executors.newFixedThreadPool(2);

service.execute(new Runnable() {

@Override

public void run() {

System.out.println("线程的名称:"+Thread.currentThread().getName());

}

});

service.execute(new Runnable() {

@Override

public void run() {

System.out.println("线程的名称:"+Thread.currentThread().getName());

}

});

 

1. 单线程线程池

效果与定长线程池 创建时传入数值1 效果一致.

/**

* 单线程线程池.

* 执行流程:

* 1. 判断线程池的那个线程是否空闲

* 2. 空闲则使用

* 3. 不空闲,则等待池中的单个线程空闲后使用

*/

ExecutorService service = Executors.newSingleThreadExecutor();

service.execute(new Runnable() {

@Override

public void run() {

System.out.println("线程的名称:"+Thread.currentThread().getName());

}

});

service.execute(new Runnable() {

@Override

public void run() {

System.out.println("线程的名称:"+Thread.currentThread().getName());

}

});

 

 

 

4.周期性任务定长线程池

public static void main(String[] args) {

/**

* 周期任务 定长线程池.

* 执行流程:

* 1. 判断线程池是否存在空闲线程

* 2. 存在则使用

* 3. 不存在空闲线程,且线程池未满的情况下,则创建线程 并放入线程池, 然后使用

* 4. 不存在空闲线程,且线程池已满的情况下,则等待线程池存在空闲线程

*

* 周期性任务执行时:

* 定时执行, 当某个时机触发时, 自动执行某任务 .*/

ScheduledExecutorService service = Executors.newScheduledThreadPool(2);

/**

* 定时执行

* 参数1. runnable类型的任务

* 参数2. 时长数字

* 参数3. 时长数字的单位

*/

/*service.schedule(new Runnable() {

@Override

public void run() {

System.out.println("俩人相视一笑~ 嘿嘿嘿");

}

},5,TimeUnit.SECONDS); //5秒后执行

*/

/**

* 周期执行

* 参数1. runnable类型的任务

* 参数2. 时长数字(延迟执行的时长)

* 参数3. 周期时长(每次执行的间隔时间)

* 参数4. 时长数字的单位

*/

service.scheduleAtFixedRate(new Runnable() {

@Override

public void run() {

System.out.println("俩人相视一笑~ 嘿嘿嘿");

}

},5,2,TimeUnit.SECONDS); //5秒后执行，每隔两秒执行一次

}

 

Runnable 与 Callable

接口定义

//Callable接口

public interface Callable<V> {

V call() throws Exception;

}

//Runnable接口

public interface Runnable {

public abstract void run();

}

Callable使用步骤

1. 编写类实现Callable接口 , 实现call方法

class XXX implements Callable<T> {

@Override

public <T> call() throws Exception {

return T;

}

}

2. 创建FutureTask对象 , 并传入第一步编写的Callable类对象

FutureTask<Integer> future = new FutureTask<>(callable);

3. 通过Thread,启动线程

new Thread(future).start();

Runnable 与 Callable的相同点

都是接口

都可以编写多线程程序

都采用Thread.start()启动线程

Runnable 与 Callable的不同点

Runnable没有返回值；Callable可以返回执行结果

Callable接口的call()允许抛出异常；Runnable的run()不能抛出 

Callable获取返回值

Callalble接口支持返回执行结果，需要调用FutureTask.get()得到，此方法会阻塞主进程的继续往下执行，如果不调用不会阻塞。

消费者与生成者

package com.java.demo;

 

import java.util.concurrent.locks.Lock;

import java.util.concurrent.locks.ReentrantLock;

 

public class Demo4  {

 

    /**

     * 多线程通信问题, 生产者与消费者问题

     * @param args

     */

    public static void main(String[] args) {

        Food f = new Food();

        new Cook(f).start();

        new Waiter(f).start();

    }

 

    //厨师

    static class Cook extends Thread{

        private Food f;

        public Cook(Food f) {

            this.f = f;

        }

 

        @Override

        public void run() {

            for(int i=0;i<100;i++){

                if(i%2==0){

                    f.setNameAndSaste("老干妈小米粥","香辣味");

                }else{

                    f.setNameAndSaste("煎饼果子","甜辣味");

                }

            }

        }

    }

    //服务生

    static class Waiter extends Thread{

        private Food f;

        public Waiter(Food f) {

            this.f = f;

        }

        @Override

        public void run() {

            for(int i=0;i<100;i++){

                try {

                    Thread.sleep(100);

                } catch (InterruptedException e) {

                    e.printStackTrace();

                }

                f.get();

            }

        }

    }

    //食物

    static class Food{

        private String name;

        private String taste;

 

        //true 表示可以生产

        private boolean flag = true;

 

        public synchronized void setNameAndSaste(String name,String taste){

            if(flag) {

                this.name = name;

                try {

                    Thread.sleep(100);

                } catch (InterruptedException e) {

                    e.printStackTrace();

                }

                this.taste = taste;

                flag = false;

                this.notifyAll();

                try {

                    this.wait();

                } catch (InterruptedException e) {

                    e.printStackTrace();

                }

            }

        }

        public synchronized void get(){

            if(!flag) {

                System.out.println("服务员端走的菜的名称是:" + name + ",味道:" + taste);

                flag = true;

                this.notifyAll();

                try {

                    this.wait();

                } catch (InterruptedException e) {

                    e.printStackTrace();

                }

            }

        }

    }

}