Loading...
墨滴

ㅤ小羊

2021/08/02  阅读:30  主题:雁栖湖

多线程

Part1多线程

1线程与进程

进程

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

线程

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

2线程调度

分时调度

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

抢占式调度

  • ​ 优先让优先级高的线程使用 CPU,如果线程的优先级相同,那么会随机选择一个(线程随机性),Java使用的为

抢占式调度。

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

3同步与异步

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

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

4Runnable与Thread

  1. Runnable的实现方式是实现其接口即可
  2. Thread的实现方式是继承其类
  3. Runnable接口支持多继承,但基本上用不到
  4. Thread实现了Runnable接口并进行了扩展,而Thread和Runnable的实质是实现的关系,不是同类东西,所以Runnable或Thread本身没有可比性。

5Runnable 与 Callable

接口定义 

//Callable接口 

public interface Callable<V> { 

 V call() throws Exception; 

}

//Runnable接口 

public interface Runnable { 

 public abstract void run(); 

}

6Callable使用步骤

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()得到,此方法会阻塞主进程的继续往下执行,如果不调用不会阻塞。

Part2线程池 Executors

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

线程池的好处

  • 降低资源消耗。
  • 提高响应速度。
  • 提高线程的可管理性。

7Java中的四种线程池 . ExecutorService

缓存线程池

/**
* 缓存线程池. 
* (长度无限制) 
* 执行流程: 
* 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. 判断线程池是否存在空闲线程 
* 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. 判断线程池 的那个线程 是否空闲 
* 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()); 
 } 
}); 

周期性任务定长线程池

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

生产者与消费者

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

ㅤ小羊

2021/08/02  阅读:30  主题:雁栖湖

作者介绍

ㅤ小羊