线程与进程

最新推荐文章于 2021-09-05 20:15:44 发布

himeme

最新推荐文章于 2021-09-05 20:15:44 发布

阅读量188

点赞数

分类专栏： Java 文章标签： java

本文链接：https://blog.csdn.net/himeme/article/details/114997502

版权

Java 专栏收录该内容

6 篇文章 0 订阅

订阅专栏

多线程

线程与进程

进程

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

线程

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

线程调度

1、分时调度

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

2、抢占式调度

优先让优先级高的线程使用 CPU，如果线程的优先级相同，那么会随机选择一个(线程随机性)，Java使用的为抢占式调度。
CPU使用抢占式调度模式在多个线程间进行着高速的切换。对于CPU的一个核而言，某个时刻，只能执行一个线程，而 CPU的在多个线程间切换速度相对我们的感觉要快，看上去就是在同一时刻运行。其实，多线程程序并不能提高程序的运行速度，但能够提高程序运行效率，让CPU的使用率更高。

同步与异步

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

并发与并行

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

Java实现

1、继承thread

public class Demo {
    public static void main(String[] args) {
        MyThread thread = new MyThread();
        thread.start();
        int i = 10;
        while (i>0) {
            System.out.println("主线程");
            --i;
        }

    }
}

public class MyThread extends Thread{
	/**
     * run方法就是线程要执行的任务方法
     */
    @Override
    public void run() {
        int i = 10;
        while (i>0){
            System.out.println("start线程");
            --i;
        }
    }
}

//匿名		
		new Thread(() -> {
            int i = 10;
            while (i>0){
                System.out.println("start线程");
                --i;
            }
        }).start();
        int i = 10;
        while (i>0) {
            System.out.println("主线程");
            --i;
        }

2、实现Runnable

//1、创建一个任务对象
MyRunnable r = new MyRunnable();
//2、创建一个线程，并为其分配一个任务
Thread t = new Thread(r);
//3、执行
t.start();

public class MyRunnable implements Runnable{
    @Override
    public void run() {
        int i = 10;
        while (i>0){
            System.out.println("start线程");
            --i;
        }
    }
}

3、实现Runnable与继承Thread相比有如下优势：

通过创建任务，然后给线程分配的方式来实现多线程，更适合多个线程同时执行相同任务的情况。
可以避免单继承带来的局限性。
任务与线程本身是分离的，提高了程序的健壮性。
后续学习线程池技术，接收Runnable类型的任务，不接收Thread类型的线程。

Thread类

1、设置和获取线程名称

//获取线程名称
System.out.println(Thread.currentThread().getName());
new Thread(new MyRunnable()).start();
new Thread(new MyRunnable()).start();
new Thread(new MyRunnable()).start();

public class MyRunnable implements Runnable{
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName());
    }
}

//初始化添加名称
Thread t = new Thread(new MyRunnable(),"线程1");
t.start();
//设置名称
t.setName("修改名称");

2、线程休眠sleep

Thread.sleep(1000);//休眠1s

3、线程阻塞

文件读取、读取用户输入数据；

4、线程中断

一个线程是一个独立的执行路径，它是否应该结束由其自身决定；

stop()过时了；

通过给线程打入中断标记结束线程；

//给t1添加中断标记
t1.interrupt();

	//主线程
		Thread t1 = new Thread(new MyRunnable());
        t1.start();
        for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName()+i);
            try {
                Thread.sleep(1000);
            }catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        //给t1添加中断标记
        t1.interrupt();
        
	static class MyRunnable implements Runnable{
        @Override
        public void run() {
            for (int i = 0; i < 10; i++) {
                System.out.println(Thread.currentThread().getName()+i);
                try {
                    Thread.sleep(1000);
                }catch (InterruptedException e) {
                    System.out.println("发现中断标记，结束线程");
                    //return 即死亡
                    return;
                }
            }
        }
	}

5、守护线程

线程分为守护线程和用户线程

用户线程：当一个进程不包含任何的存活的用户线程时，结束；
守护线程：用于守护用户线程的，当最后一个用户线程结束时，所有守护线程自动死亡。

//设置t1为守护线程，主线程死亡，t1死亡
t1.setDaemon(true);

线程安全

1、同步代码块（隐式锁）

格式：synchronized(锁对象){}

public static void main(String[] args) throws InterruptedException {
        Ticket t = new Ticket();
        new Thread(t).start();
        new Thread(t).start();
        new Thread(t).start();

    }
    static class Ticket implements Runnable{
        private int count = 10;
        private Object o = new Object();
        @Override
        public void run() {
                while (true) {
                    synchronized (o){
                        if (count>0){
                            			 System.out.println(Thread.currentThread().getName()+"正在卖票");
                            try {
                                Thread.sleep(1000);
                            }catch (InterruptedException e) {
                                e.printStackTrace();
                            }
                            count--;
                            System.out.println("出票成功，余票为："+count);
                        }else {
                            break;
                        }
                    }
                }

        }
    }

锁对象应该是同一把锁；
线程0会一直抢占执行售票，刚把锁解除就重新抢占了锁。

2、同步方法（隐式锁）

synchronized修饰方法名

static class Ticket implements Runnable{
        private int count = 10;
        @Override
        public void run() {
                while (true) {
                    boolean flag = sale();
                    if (!flag){
                        break;
                    }
                }
        }

        public synchronized boolean sale(){
            if (count>0){
                System.out.println(Thread.currentThread().getName()+"正在卖票");
                try {
                    Thread.sleep(500);
                }catch (InterruptedException e) {
                    e.printStackTrace();
                }
                count--;
                System.out.println("出票成功，余票为："+count);
                return true;
            }else {
                return false;
            }
        }
    }

3、显示锁Lock

子类：ReentrantLock

private Lock l = new ReentrantLock();

		@Override
        public void run() {
                while (true) {
                    l.lock();
                    if (count>0){
                        System.out.println(Thread.currentThread().getName()+"正在卖票");
                        try {
                            Thread.sleep(500);
                        }catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        count--;
                        System.out.println("出票成功，余票为："+count);
                    }else {
                        break;
                    }
                    l.unlock();
                }
        }

4、显示锁和隐式锁的区别

1、层面不同

synchronized：Java中的关键字，是由JVM来维护的，是JVM层面的锁。
- synchronized底层是通过monitorenter进行加锁
  底层是通过monitor对象来完成的，其中的wait/notify等方法也是依赖于monitor对象的。并且只有在同步块或同步方法中，JVM才会调用monitory对象的，才可以调用wait/notify等方法
- 通过monitorexit来退出锁
Lock：是JDK5以后才出现的具体的类。使用lock是调用对应的API，是API层面的锁。
- lock是通过调用对应的API方法来获取锁和释放锁的。

2、使用方式不同

synchronized
程序能够自动获取锁和释放锁。Sync是由系统维护的，如果非逻辑问题的话话，不会出现死锁。
Lock
需要手动的获取和释放锁。如果没有释放锁，就有可能导致出现死锁的现象。
手动获取锁方法：lock.lock()。释放锁：unlock方法。并且需要配合tyr/finaly语句块来完成。

3、等待是否可中断

synchronized
不可中断，除非抛出异常或者正常运行完成。
Lock
可以中断的。
中断方式：
- 调用设置超时方法tryLock(long timeout ,timeUnit unit)
- 调用lockInterruptibly()放到代码块中，然后调用interrupt()方法可以中断

4、加锁的时候是否可以设置成公平锁

synchronized
只能为非公平锁。
lock：两者都可以的。默认是非公平锁。
在其构造方法的时候可以传入Boolean值。true：公平锁、false：非公平锁

5、锁绑定多个条件来condition

synchronized
不能精确唤醒线程。要么随机唤醒一个线程；要么是唤醒所有等待的线程。
Lock
用来实现分组唤醒需要唤醒的线程，可以精确的唤醒。

6、性能区别

synchronized

托管给JVM执行，Java1.5中，由于需要调用操作接口，可能导致加锁消耗时间过长，与Lock性比性能低。1.6以后，语义定义更加清晰，有适应自旋、锁粗化、锁消除、轻量级锁、偏向锁等，可进行许多优化，性能提高了，与Lock差不多。
Lock
java写的控制锁的代码，性能高。

5、公平锁和非公平锁

公平锁：排队，先到先得；
非公平锁：抢占。

显示锁可以设置

private Lock l = new ReentrantLock(true);//为true是公平锁

6、线程死锁

死锁概述
线程死锁是指两个或两个以上的线程互相持有对方所需要的资源，由于synchronized的特性，一个线程持有一个资源，或者说获得一个锁，在该线程释放这个锁之前，其它线程是获取不到这个锁的，而且会一直死等下去，因此这便造成了死锁。
死锁产生的条件
1、互斥条件：一个资源，或者说一个锁只能被一个线程所占用，当一个线程首先获取到这个锁之后，在该线程释放这个锁之前，其它线程均是无法获取到这个锁的。
2、占有且等待：一个线程已经获取到一个锁，再获取另一个锁的过程中，即使获取不到也不会释放已经获得的锁。
3、不可剥夺条件：任何一个线程都无法强制获取别的线程已经占有的锁
4、循环等待条件：线程A拿着线程B的锁，线程B拿着线程A的锁。
如何避免死锁

1、加锁顺序：线程按照相同的顺序加锁。

2、加锁时限：线程获取锁的过程中限制一定的时间，如果给定时间内获取不到，就算了，别勉强自己。这需要用到Lock的一些API。

多线程通信生产者消费者

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

线程状态

NEW:尚未启动的线程；
RUNNABLE:在Java虚拟机中执行的线程；
BLOCKED:被阻塞等待监视器锁定的线程；
WAITING:无限期等待另一个线程执行特定操作的线程；
TIMED_WAITING:正在等待另一个线程执行最多指定等待时间的操作的线程；
TERMINATED:已退出的线程。

带返回值的线程Callable(第三种线程创建方式)

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

	public static void main(String[] args) throws ExecutionException, InterruptedException {
        Callable<Integer> c = new MyCallable();
        FutureTask<Integer> futureTask = new FutureTask<>(c);
        new Thread(futureTask).start();
        Integer j = futureTask.get();
        System.out.println(j);
        for (int i = 0; i < 10; i++) {
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(i);
        }
    }
    static class MyCallable implements Callable<Integer>{

        @Override
        public Integer call() throws Exception {
            Thread.sleep(1000);
            return 100;
        }
    }

判断线程是否执行完成：

boolean done = futureTask.isDone();

取消线程：

boolean cancel = futureTask.cancel(true);

线程池

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

线程池的好处

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

Java中的四种线程池 . ExecutorService

1. 缓存线程池

(长度无限制)

执行流程:

判断线程池是否存在空闲线程
存在则使用
不存在,则创建线程并放入线程池, 然后使用

ExecutorService service = Executors.newCachedThreadPool();
        service.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+"12345");
            }
        });
        service.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+"12345");
            }
        });
        service.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+"12345");
            }
        });

2. 定长线程池

(长度是指定的数值)

执行流程：

判断线程池是否存在空闲线程
存在则使用
不存在空闲线程,且线程池未满的情况下,则创建线程并放入线程池, 然后使用
不存在空闲线程,且线程池已满的情况下,则等待线程池存在空闲线程

ExecutorService service = Executors.newFixedThreadPool(2);

3. 单线程线程池

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

执行流程:

判断线程池的那个线程是否空闲
空闲则使用
不空闲,则等待池中的单个线程空闲后使用

ExecutorService service = Executors.newSingleThreadExecutor();

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

执行流程:

判断线程池是否存在空闲线程
存在则使用
不存在空闲线程,且线程池未满的情况下,则创建线程并放入线程池, 然后使用
不存在空闲线程,且线程池已满的情况下,则等待线程池存在空闲线程

周期性任务执行时:

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

定时执行：

参数1. runnable类型的任务
参数2. 时长数字
参数3. 时长数字的单位

		ScheduledExecutorService service = Executors.newScheduledThreadPool(2);
        service.schedule(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+":12345");
            }
        },5, TimeUnit.SECONDS);

周期执行：

参数1. runnable类型的任务

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

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

参数4. 时长数字的单位

		ScheduledExecutorService service = Executors.newScheduledThreadPool(2);
        service.schedule(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+":12345");
            }
        },5, TimeUnit.SECONDS);
        service.scheduleAtFixedRate(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+":12345");
            }
        },5,1,TimeUnit.SECONDS);

Lambda表达式：函数式编程思想

面向对象：创建对象调用方法，解决问题；

函数式编程思想关注的是结果

Thread t = new Thread(()->{
            System.out.println(Thread.currentThread().getName()+":12345");
        });
        t.start();

himeme

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫

专栏目录