Java多线程学习

第一次写博客，主要记录下自己在学习Java道路上的一些知识点，最近在学习多线程的内容，以下是对多线程的东西进行了总结。

线程和进程

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

线程调度

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

同步与异步

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

并发与并行

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

多线程技术

实现Runnabale 与 继承Thread相比有如下优势:
1.通过创建任务，然后给线程分配的方式来实现的多线程。更适合多个线程同时执行相同任务的情况。
2.可以避免单继承所带来的局限性。
3.任务与线程本身是分离的，提高程序的健壮性。
4.后续学习的线程池技术，接受Runnable类型的任务，不接受Thread类型的线程。

线程的创建方式

1.继承Thread类

public class MyThread extends Thread{
    @Override
    public void run() {
        for(int i=0;i<10;i++) {
            System.out.println("测试"+i);
        }
    }
}

测试代码：

public class demo1 {
    public static void main(String[] args) {
        MyThread mt = new MyThread();
        mt.start();
        
        for(int i=0;i<10;i++) {
            System.out.println("主线程"+i);
        }
    }
}

2.实现Runnable接口

public class MyRunnable implements Runnable{
    @Override
    public void run() {
        for(int i=0;i<10;i++) {
            System.out.println("测试"+i);
        }
    }
}

测试代码

public class demo1 {
    public static void main(String[] args) {
        MyRunnable mr = new MyRunnable();
        Thread t = new Thread(mr);
        t.start();
        for(int i=0;i<10;i++) {
            System.out.println("主线程"+i);
        }
    }
}

线程类型

用户线程：当一个进程不包含任何的存活的用户线程时，进程结束
守护线程：守护用户线程的，当最后一个用户线程结束时，所有守护线程自动死亡。
setDaemon(true) 设置线程为守护线程

线程安全问题

线程不安全解决方案1：同步代码块 synchronized(隐式锁)

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

解决方案2：同步方法(隐式锁)

static class Ticket implements Runnable{
        //票数
        private int count = 10;
        Object o  = new Object();
        @Override
        public void run() {
            while (true){
                boolean b = sale();
                if(!b){
                    break;
                }
            }
        }

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

解决方案3：显式锁 lock 子类 ReentrantLock

static class Ticket implements Runnable{
        //票数
        private int count = 10;
        //显示锁
        Lock l = new ReentrantLock();

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

公平锁和不公平锁：

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

线程状态

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