多线程学习笔记——菜鸟日记（上）

多线程学习笔记——菜鸟日记（上）

一、进程与线程

进程——指一个内存中运行的应用程序，每个进程都有一个独立的内存空间（都有自己的栈、堆）；
线程——是进程中的一个执行路径，共享一个内存空间，线程之间可以自由切换，并发执行； 一个进程最少有一个线程，一个进程启动之后，里面的若干执行路径又可以划分成若干个线程。

二、线程的调度

根据不同的调度模式进行线程的高速切换，看上去似乎是同时进行。
如在电脑中的运行的程序，很多在操作中认为是同步运行的程序，其实是不同线程在很短的时间内完成切换。

三、同步与异步

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

四、并发与并行

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

五、继承Thread

继承Thread重写run方法格式如下：

public class MyThread extends Thread{
    //run方法就是线程要执行的任务方法
    //这里的代码就是一条新的执行路径
    //这个执行路径是触发方式，不是调用run方法，而是通过thread对象的start方法来启动任务
public void run(){
   for(...){
   ...
   }
}


//此处默认下面的start触发的run方法与下面的循环代码相同
public class Demo{
public static void main(String[] args) {
MyThread m = new MyThread();
m.start();
for(...){
...
}
}

代码运行的结果不一定按照某种顺序，可能出现交替运行的现象。这就是又创建了一个线程的方法。

流程图如下：

每个线程都有自己的栈空间，共用一份堆内存，子线程调用的方法都在子线程里运行。

六、实现Runnable

通过创建Runnable对象来执行任务：

实现Runnable与继承Thread相比有如下优势:

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

七、Thread类

通过API可以看到构造方法：
以及其他的方法：

八、设置和获取线程的名称

九、线程的休眠sleep

即间隔1000毫秒打印一个i

十、线程阻塞

举个形象的例子：某个程序必须等用户输入完才能继续执行，不然就会一直等待用户输入。

十一、线程的中断

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

当主线程的循环结束时，让t1线程中断，interrupt只作中断标记，决定是否中断取决于本身InterruptedException，用return直接中断线程。

十二、守护线程

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

意味着主线程死亡的时候，t1这个线程就算没有执行完也会死亡。

十三、线程安全问题

以卖票系统为例：

package thread;
public class Demo7 {
    public static void main(String[] args) {
        //线程不安全
        Runnable run = new Ticket();
        new Thread(run).start();
        new Thread(run).start();
        new Thread(run).start();
    }

    static class Ticket implements Runnable{
        //总票数
        private int count = 10;
        @Override
        public void run() {
            while (count>0){
                //卖票
                System.out.println("正在准备卖票");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                count--;
                System.out.println("卖票结束,余票："+count);
            }
        }
    }
}

此处有三个线程同时运行，那么会存在打印出来余票为-1、-2 的现象，这就是线程不安全的问题。

解决方案：

方案一：线程排队
//线程同步synchronized

public class Demo8 {
    public static void main(String[] args) {
        Object o = new Object();
        //线程不安全
        //解决方案1  同步代码块
        //格式：synchronized（锁对象）{
             }


        Runnable run = new Ticket();
        new Thread(run).start();
        new Thread(run).start();
        new Thread(run).start();
    }

    static class Ticket implements Runnable{
        //总票数
        private int count = 10;
        private Object o = new Object();//看同一把锁
        @Override
        public void run() {
            //Object o = new Object();    //这里不是同一把锁，所以锁不住
             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;
                        }

                }
            }
        }
    }
}

结果如下：三个线程排队抢

方案二：线程同步（隐示锁）
package thread;
//线程同步synchronized

public class Demo9 {
    public static void main(String[] args) {
        Object o = new Object();
        //线程不安全
        //解决方案2  同步方法
        Runnable run = new Ticket();
        new Thread(run).start();
        new Thread(run).start();
        new Thread(run).start();//如果三个线程每一个都是new Ticket任务，就不再排队
   }

    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("正在准备卖票");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                count--;
                System.out.println(Thread.currentThread().getName()+"卖票结束,余票：" + count);
                return true;
            }
                return false;

        }
    }
}

方案三：（显示锁）
package thread;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;


//同步代码块和同步方法都属于隐式锁
//线程同步lock

public class Demo10 {
    public static void main(String[] args) {
        Object o = new Object();
        //线程不安全
        //解决方案1   显示锁  Lock  子类 ReentrantLock

        Runnable run = new Ticket();
        new Thread(run).start();
        new Thread(run).start();
        new Thread(run).start();
    }

    static class Ticket implements Runnable{
        //总票数
        private int count = 10;
        //参数为true表示公平锁    默认是false 不是公平锁
        private Lock l = new ReentrantLock(true);
        @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();
            }
        }
    }
}

（来自某网友的分析，我简单整理了一下）

显示锁和隐示锁的区别：
①原始构成：synchronized （隐示锁）是JVM层面的锁；Lock是（显示锁）API层面的锁；
②使用方式：隐示锁不需要手动获取和释放锁，显示锁需要手动获取和释放锁；
③等待是否中断：synchronized一般不可中断，除非程序执行完或者抛出异常；Lock可以中断（调用tryLock(long timeout,timeUnit unit)）或者（interrupt()）；
④加锁是否公平：隐示锁—非公平锁；显示锁：两者都可，默认非公平锁；
⑤线程唤醒：synchronized：随机唤醒或者唤醒所有线程；Lock：实现分组唤醒线程，比较精确

公平锁与非公平锁：
（结合隐示锁与显示锁的区别来看）
//参数为true表示公平锁 默认是false 不是公平锁
private Lock l = new ReentrantLock(true);

十四、线程死锁

以一段警匪大片经典对话：

罪犯：你放了我，我放了人质
警察：你放了人质，我放了你

为例

package thread;
public class Demo11 {
    public static void main(String[] args) {
        //线程死锁
        Culprit c = new Culprit();
        Police p = new Police();
        new MyThread(c,p).start();
        c.say(p);
    }

    static class MyThread extends Thread{
        private Culprit c;
        private Police p;
        MyThread(Culprit c,Police p){
            this.c = c;
            this.p = p;
        }

        @Override
        public void run() {
            p.say(c);
        }
    }
    static class Culprit{
        public synchronized void say(Police p){
            System.out.println("罪犯：你放了我，我放了人质");
            p.fun();
        }
        public synchronized void fun(){
            System.out.println("罪犯被放了，罪犯也放了人质");
        }
    }
    static class Police{
        public synchronized void say(Culprit c){
            System.out.println("警察：你放了人质，我放了你");
            c.fun();
        }
        public synchronized void fun(){
            System.out.println("警察救了人质，但是罪犯跑了");
        }
    }
}

运行结果出现了卡死的现象：
罪犯：你放了我，我放了人质
警察：你放了人质，我放了你
当然电脑配置越差，多运行几次可能出现某次正常运行，这里来解释为什么会卡死：
在 c.say( p )调用say方法时，子线程开始启动p.say( c )的say方法。当主线程调用p对象时，p的子线程还没走完，子线程要调用c对象，c对象也没走完，说明双方出现了卡死的现象。