Java 多线程

em，听说多线程是面试的重点。第一次学习的时候，只是粗略的看了一下，很多概念并不是很清楚。这次整理一下，免得白学

线程与进程

进程

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

线程

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

线程调度

分时调度

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

抢占式调度

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

同步与异步

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

并发与并行

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

创建线程的常用方法

继承Thread类:

public class ThreadDemo extends Thread{

    public ThreadDemo(String name) {
        super(name);
    }

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + " Hello");
    }

    public static void main(String[] args) {
        new ThreadDemo("自定义线程").start();
        System.out.println(Thread.currentThread().getName() + " Hello");
    }
}

实现Runnable接口

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

    public static void main(String[] args) {
        new Thread(new RunnableDemo(), "自定义线程").start();
        System.out.println(Thread.currentThread().getName() + " Hello");
    }
}

实现Runnable 与集成Thread相比有如下优势：

通过创建任务，给线程分配任务实现多线程，更适合多线程同时执行相同的任务情况
2. 避免单继承带来的局限性
3. 任务与线程本身是分离的，提高了程序的健壮性
4. 后续学习的线程技术，只接受Runnable类型的任务，不接受Thread类型的线程

线程安全问题

当多个线程操作同一个数据的时候会出现线程安全问题

public class Demo04 {
    /**
     * 线程安全问题
     *
     * @param args
     */
    private static int count = 100;

    public static void main(String[] args) {
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                while (count > 0) {
                    System.out.println(Thread.currentThread().getName() + ":" + "当前票数为:" + count);
                    count--;
                    System.out.println(Thread.currentThread().getName() + ":" + "当前票数为:" + count);
                }
            }
        };

        new Thread(runnable, "线程一").start();
        new Thread(runnable, "线程二").start();
        new Thread(runnable, "线程三").start();
        new Thread(runnable, "线程四").start();
    }
}

线程二:当前票数为:100
线程三:当前票数为:100
线程三:当前票数为:98
线程一:当前票数为:100
线程一:当前票数为:97
...
线程三:当前票数为:4
线程一:当前票数为:5
线程一:当前票数为:-2
线程三:当前票数为:-1
线程二:当前票数为:0

线程安全问题解决方案

解决方案一同步代码块

public class 同步代码块 {

    public static void main(String[] args) {
        Runnable runnable = new Runnable() {
            //隐式锁
            //锁对象
            private Object o = new Object();
            private int count = 100;

            @Override
            public void run() {
                while (true) {
                    synchronized (o) {
                        if (count > 0) {
                            System.out.println(Thread.currentThread().getName() + " count = " + count);
                            count--;
                        } else {
                            break;
                        }
                    }
                }
            }
        };

        new Thread(runnable, "线程一").start();
        new Thread(runnable, "线程二").start();
        new Thread(runnable, "线程三").start();
    }
}

解决方案一同步方法

public class 同步方法 {

    public static void main(String[] args) {
        Runnable runnable = new Runnable() {
            private int count = 100;

            @Override
            public void run() {
                while (true) {
                    if (!reduce()){
                        break;
                    }
                }
            }

            public synchronized boolean reduce() {
                if (count > 0) {
                    System.out.println(Thread.currentThread().getName() + " count = " + count);
                    count--;
                    return true;
                }
                return false;
            }
        };

        new Thread(runnable, "线程一").start();
        new Thread(runnable, "线程二").start();
        new Thread(runnable, "线程三").start();
    }
}

线程一 count = 100
线程一 count = 99
线程一 count = 98
线程一 count = 97
...
线程一 count = 87
线程一 count = 86
...
线程一 count = 4
线程一 count = 3
线程一 count = 2
线程一 count = 1

多线程的各种锁

隐式锁（同步代码块，同步方法）
显示锁

public class 显示锁 {

    /**
     * 显示锁: Lock 子类 ReentrantLock
     *
     * @param args
     */
    public static void main(String[] args) {
        Runnable runnable = new Runnable() {
            private int count = 100;
            private Lock lock = new ReentrantLock();

            @Override
            public void run() {
                while (true) {
                    lock.lock();
                    if (count > 0) {
                        System.out.println(Thread.currentThread().getName() + " count = " + count);
                        count--;
                    } else {
                        break;
                    }
                    lock.unlock();
                }
                System.out.println("bye");
            }
        };

        new Thread(runnable, "线程一").start();
        new Thread(runnable, "线程二").start();
        new Thread(runnable, "线程三").start();
    }
}

公平锁和非公平锁
线程死锁

线程的七种状态

born（新生状态）
runnable（就绪状态）
running（运行状态）
waiting（等待状态）
sleeping（睡眠状态）
blocked（阻塞状态）
dead（死亡状态）

Callable

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

线程池 Executors

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

线程池的好处

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

Java中的四种线程池 . ExecutorService

缓存线程池

public class 缓存线程池 {
    /**
     *  缓存线程池.
     *  (长度无限制)
     *  执行流程:
     *  1. 判断线程池是否存在空闲线程
     *  2. 存在则使用
     *  3. 不存在,则创建线程 并放入线程池, 然后使用
     */
    public static void main(String[] args) {
        ExecutorService service = Executors.newCachedThreadPool();
        service.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + " Java");
            }
        });

        service.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + " Java");
            }
        });

        service.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + " Java");
            }
        });
    }
}

pool-1-thread-1 Java
pool-1-thread-2 Java
pool-1-thread-2 Java

定长线程池

public class 定长线程池 {

    /** 定长线程池.
     *  (长度是指定的数值)
     *  执行流程:
     * 1. 判断线程池是否存在空闲线程
     * 2. 存在则使用
     * 3. 不存在空闲线程,且线程池未满的情况下,则创建线程 并放入线程池, 然后使用
     * 4. 不存在空闲线程,且线程池已满的情况下,则等待线程池存在空闲线程
     */
    public static void main(String[] args) {
        ExecutorService service = Executors.newFixedThreadPool(2);

        service.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + " Java");
            }
        });

        service.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + " Java");
            }
        });


        service.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + " Java");
            }
        });

        service.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + " Java");
            }
        });
    }
}

pool-1-thread-1 Java
pool-1-thread-2 Java
pool-1-thread-1 Java
pool-1-thread-2 Java

单线程线程池
效果与定长线程池创建时传入数值1 效果一致.
周期性任务定长线程池

posted @ 2021-07-24 22:07 王^.^令阅读(42) 评论(0) 收藏举报

刷新页面返回顶部

王^.^令