java线程--基础篇

一：为什么要学多线程

    如果是单线程，所有的任务顺序执行，非常浪费时间，而且处理量有限，比如下课去食堂打饭，只有一个窗口所有同学排队等着阿姨打饭。多线程可以理解为食堂又开通了多个窗口，多个窗口同时排队打饭效率是不是就大大提升了。同样当开通了多个窗口就会引发多个问题。比如A窗口的同学都喜欢吃红烧肉，结果A窗口那边红烧肉卖的很快，一会就卖光了，B窗口阿姨刚收完同学红烧肉的钱 结果去看才知道卖光了。这个仅仅是生活中简单处理的情况。

二：进程与线程

1. 进程

进程是资源（CPU、内存等）分配的基本单位，它是程序执行时的一个实例。程序运行时系统就会创建一个进程，并为它分配资源，然后把该进程放入进程就绪队列，进程调度器选中它的时候就会为它分配CPU时间，程序开始真正运行。

2. 线程

线程是一条执行路径，是程序执行时的最小单位，它是进程的一个执行流，是CPU调度和分派的基本单位，一个进程可以由很多个线程组成，线程间共享进程的所有资源，每个线程有自己的堆栈和局部变量。线程由CPU独立调度执行，在多CPU环境下就允许多个线程同时运行。同样多线程也可以实现并发操作，每个请求分配一个线程来处理。

3. 进程与线程的关系

你可以这么理解，当你要看电影时，首先打开播放器，其中播放音乐的是一个线程，播放视频是一个线程，甚至突然屏幕上弹出的广告都是一个线程。这么多线程结合一起称为一个进程。进程进行线程的调配工作。

 

三. 线程创建方式

  

public class Demo {

    public static void main(String[] args) {

        /**
         * 简单创建方式一
         */
        Thread thread1 = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName());
            }
        });
        thread1.start();

        /**
         * 简单创建方式二
         */
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName());

            }
        };
        Thread thread2 = new Thread(runnable);
        thread2.start();
        

    }
}

 

四：线程的状态

1.     创建（new）状态: 准备好了一个多线程的对象，即执行了new Thread(); 创建完成后就需要为线程分配内存

2.     就绪（runnable）状态: 调用了start()方法, 等待CPU进行调度
3.     运行（running）状态: 执行run()方法
4.     阻塞（blocked）状态: 暂时停止执行线程，将线程挂起(sleep()、wait()、join()、没有获取到锁都会使线程阻塞), 可能将资源交给其它线程使用
5.     死亡（terminated）状态: 线程销毁(正常执行完毕、发生异常或者被打断interrupt()都会导致线程终止)

 

五：线程常用方法

一，sleep（）

Thread.sleep(long millis)和Thread.sleep(long millis,int nanos)静态方法强制当前正在执行的线程休眠（即暂停执行）。当线程睡眠时，它睡在某个地方，并不占用cpu，在苏醒之前是不会返回到可运行状态。当睡眠时间到期，则返回到可运行的状态。所以，sleep()方法指定的时间为线程不会运行的最短时间。当线程休眠时间结束后，会返回到可运行状态，注意不是运行状态，如果要到运行状态还需要等待CPU调度执行。

        new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    System.out.println("开始睡眠");
                    Thread.sleep(10000);
                    System.out.println("睡眠结束");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName());
            }
        }).start();

二，join（）

调用线程等待该线程完成后，才能继续用下运行。可以理解为调用某个线程，当这个线程执行完后我才能往下面运行

package com.thread.demo;

public class JoinDemo {

    static int i = 0;

    public static void main(String[] args) throws InterruptedException {

        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    Thread.sleep(1000);
                    i++;
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("t1执行结束");
            }
        });


        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    Thread.sleep(1000);
                    i++;
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("t2执行结束");
            }
        });
        t1.start();
//        t1.join();
        t2.start();

        System.out.println("main执行结束,i当前为："+i);

    }
}

在没有join方法时 输出

main执行结束,i当前为：0
t2执行结束
t1执行结束

加入join方法是 输出

        t1.start();
        t1.join();
        t2.start();

        System.out.println("main执行结束,i当前为："+i);

t1执行结束
main执行结束,i当前为：1
t2执行结束

三，yeild（）

让当前运行线程回到可运行状态，以允许具有相同优先级的其他线程获得运行机会。因此，使用yield()的
目的是让相同优先级的线程之间能适当的轮转执行。但是，实际中无法保证yield()达到让步目的，因为让步的线程还有可能被
线程调度程序再次选中。