多线程

多线程

一、进程与线程

进程：
是指一个内存中正在运行的应用程序，每个进程都有一个独立的内存空间。是系统进行资源分配和调用的独立单位。
线程：
是进程中的一个执行路径，共享一个内存空间，线程之间可以自由切换，并发执行. 一个进程最少有一个线程。
每个线程都有自己的栈内存，公用一份堆内存。
线程实际上是在进程基础之上的进一步划分，一个进程启动之后，里面的若干执行路径又可以划分成若干个线程。
单线程：一个进程若只有一条执行路径，则为单线程程序
多线程：一个进程若有多条执行路径，则为多线程程序

二、线程调度

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

抢占式调度：
优先让优先级高的线程使用 CPU，如果线程的优先级相同，那么会随机选择一个(线程随机性)。优先级高的线程获取的CPU时间片相对多一些。

Java使用的为抢占式调度。

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

三、同步与异步

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

四、并发与并行

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

五、多线程的实现方法

方法一：继承Thread类
定义一个类MyThread继承Thread类在这里插入代码片
在MyThread类中重写run()方法
创建MyThread类的对象
启动线程

public class Demo{
    public static void main(String[] args){ 
       MyThread m = new MyThread();
       m.start();
    }
}

public class MyThread extends Thread{
       @override
       public void run(){
       //这里的代码就是一条新的执行路径
       //这个执行路径的触发方式，不是调用run方法
       //而是通过thread对象的start()来启动任务
       
       //获取当前线程名称
       System.out.pringln(Thread.currentThread().getName());
       }
}``

方法二：实现Runnable接口
定义一个类MyRunnable实现Runnable接口
在MyRunnable类中重写run()方法
创建MyRunnable类的对象
创建Thread类的对象，把MyRunnable对象作为构造方法的参数
启动线程

public class Demo{
      public static void main(String[] args){
       //创建一个任务对象
       MyRunnable r = new Runnable();
       //创建一个线程，并为其分配一个任务
       Thread t = new Thread();
       //执行这个线程
       t.start();
       } 
}

public classs MyRunnable implements Runnable{
@override
 public void run(){
 }
}

相比继承Thread类，实现Runnable接口的好处：
1.通过创建任务，然后给线程分配的方式来实现多线程，更适合多个线程同时执行相同任务的情况
2.可以避免单继承所带来的局限性
3.任务与线程本身是分离的，提高了程序的健壮性
4.线程池，接受Runnable类型的任务，不接收Thread类型的线程

六、线程安全问题

解决方案一：同步代码块（隐式锁）

锁多条语句操作共享数据，可以使用同步代码块实现
格式：
synchronized(对象){
//多条语句操作共享数据的代码
}

synchronized(对象) 就相当于给代码加锁了，对象就可以看成是一把锁

好处与弊端：
好处：解决了多线程的数据安全问题
弊端：当线程很多时，因每个线程都会去判断同步上的锁，就很耗费资源，降低了程序的运行效率

解决方案二：同步方法（隐式锁）

把synchronized关键字加到方法上
格式：
修饰符 synchronized 返回值类型方法名(方法参数){ }

同步方法的锁对象： this

同步静态方法：把synchronized关键字加到静态方法上
格式：
修饰符 static synchronized 返回值类型方法名(方法参数){}

同步静态方法的锁对象：类名.class

解决方案三：Lock 子类 ReentrantLock（显示锁）

Lock实现提供比使用synchronized方法和语句可以获得更广泛的锁定操作
Lock中提供了获得锁和释放锁的方法
void lock() 获得锁
void unlock() 释放锁
Lock是接口不能直接实例化，采用实现类ReentrantLock来实例化
ReentrantLock() 创建一个ReentrantLock的实例

显示锁l：fair参数为true就表示是公平锁
private Lock l = new ReentrantLock(true);

七、Runnable 与 Callable

接口定义
//Callable接口
public interface Callable {
V call() throws Exception;
}
//Runnable接口
public interface Runnable {
public abstract void run();
}

Callable使用步骤

1. 编写类实现Callable接口 , 实现call方法
   class XXX implements Callable {
   @Override
   public call() throws Exception {
   return T;
   }
   }
2. 创建FutureTask对象 , 并传入第一步编写的Callable类对象
   FutureTask future = new FutureTask<>(callable);
3. 通过Thread,启动线程
   new Thread(future).start();

Runnable 与 Callable的相同点：
1.都是接口
2.都可以编写多线程程序
3.都采用Thread.start()启动线程

Runnable 与 Callable的不同点：
Runnable没有返回值；Callable可以返回执行结果；
Callable接口的call()允许抛出异常；Runnable的run()不能抛出

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

八、线程池 Executors

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

线程池的好处：
1.降低资源消耗
2.提高响应速度
3.提高线程的可管理性。

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());
}
});

2. 定长线程池

/**
* 定长线程池.
* (长度是指定的数值)
* 执行流程:
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());
}
});

3. 单线程线程池

效果与定长线程池 创建时传入数值1 效果一致.
/**
* 单线程线程池.
* 执行流程:
* 1. 判断线程池 的那个线程 是否空闲
* 2. 空闲则使用
* 4. 不空闲,则等待 池中的单个线程空闲后 使用
*/
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);
*/
/**
* 周期执行
* 参数1. runnable类型的任务
* 参数2. 时长数字(延迟执行的时长)
* 参数3. 周期时长(每次执行的间隔时间)
* 参数4. 时长数字的单位
*/
service.scheduleAtFixedRate(new Runnable() {
@Override
public void run() {
System.out.println("俩人相视一笑~ 嘿嘿嘿");
}
},5,2,TimeUnit.SECONDS);

九、生产者与消费者实例

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class Demo  {

    /**
     * 多线程通信问题, 生产者与消费者问题
     * @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();
                }
            }
        }
    }
}