Java 线程

---

什么是进程与线程

进程：一个操作系统中可以同时运行多个任务（程序），每个运行的任务（程序）被称为一个进程。进程是系统进行资源分配和调度的一个独立单元。
线程：一个程序可以多次运行多个任务（顺序执行流），那个每个任务（顺序执行流）就叫做一个线程。是程序执行流的最小单元。

什么是并发

并发：线程是并发运行的。操作系统把时间化成若干个片段（时间片），尽可能地平均分给每个任务，被分配时间片后，任务就有机会被CPU执行。微观上看，每个任务都是走走停停的。但随着CPU高效地执行，宏观上看所有任务都在运行。这种都运行的现象称之为并发，但不是绝对意义上的“同时发生”。

Thread类

Thread类 的实例代表一个并发任务。任何线程对象都是Thread类的（子类）实例，Thead类是线程的模板，它封装了复杂的线程开启等操作，封装了操作系统的差异性。因此并发的任务逻辑实现只是重写Thread的run方法即可。
Thread本身就实现了Runnable接口

线程调度

线程调度机制会将所有的并发任务做统一的调度工作，划分时间片（可以被CPU执行的时间）给每一个任务，时间片尽可能的均匀，但做不到绝对均匀。同样，被分配时间片后，该任务被CPU执行，但调度的过程中不能保证所有任务都是平均的获取时间片的次数，只能做到尽可能平均。这两个都是程序不可控的。

线程状态图

线程的启动和停止

void start() 想并发操作不要直接调用run方法，而是调用线程的start()方法启动线程。
void stop() 不要直接使用stop()方法来停止线程的运行，这是不安全的操作，想让线程停止，应该通过run方法的执行完毕来进行自然的结束

Runnable 接口

用于定义线程要执行的任务逻辑。将线程与其执行的任务分离开。 Thread(Runnable runnable) 解耦的思想。

线程睡眠阻塞

使当前线程放弃CPU时间，进入阻塞状态。在阻塞状态下的线程不会分配时间片。直到该线程结束阻塞状态回到Runnable状态，方可再次获得时间片来让CPU运行（进入Running）。
static void sleep(long millis)方法：让当前线程主动进入Block阻塞状态，并在time毫秒后回到Runnable状态。sleep()不会释放锁。

 // 注意事项： 使用Thread.sleep()方法阻塞线程时，强制让我们必须捕获“中断异常”。引发情况：当前线程处于sleep阻塞期间，被另一个线程中断中断阻塞状态时，当前线程会抛出该异常。
   public static void main(String[] args) {
         int i=0;
         while(true){
             System.out.println(i+"秒");
             i++;
             try {
                 Thread.sleep(1000);
             } catch (InterruptedException e) {
                 e.printStackTrace();
             }
         }
    }

打断/唤醒 线程

void interrupt()方法： 打断/唤醒 线程。一个线程可以提前唤醒另一个sleep Block的线程。

public class ThreadDemo3 {

    /**
     * void interrupt()方法： 打断/唤醒 线程。一个线程可以提前唤醒另一个sleep Block的线程。
     * 方法中定义的类叫做局部内部类。局部内部类中，若想引用当前方法的其他局部变量，那么该变量必须是final的。
     */
    public void fun(){
        final Thread lin = new Thread() {
            public void run() {
                System.out.println("林：睡觉了......");
                try {
                    Thread.sleep(10000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                    System.out.println("林： 干嘛呢！干嘛呢！干嘛呢！");
                    System.out.println("林： 干嘛呢！都破了相了");
                }
            }
        };
        lin.start(); //开启第一个线程
        Thread huang = new Thread() {
            public void run() {
                System.out.println("80 一锤子，您说咂哪儿？");
                for (int i = 0; i < 5; i++) {
                    System.out.println("80!");
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }

                System.out.println("咣当！");
                System.out.println("黄：搞定！");
                lin.interrupt();  //中断第一个线程的阻塞状态


            }
        };
        huang.start(); //启动第二个线程
    }

    public static void main(String[] args) {
        new ThreadDemo3().fun();
    }

}

输出结果：

80 一锤子，您说咂哪儿？
80!
林：睡觉了......
80!
80!
80!
80!
咣当！
黄：搞定！
java.lang.InterruptedException: sleep interrupted
	at java.lang.Thread.sleep(Native Method)
林： 干嘛呢！干嘛呢！干嘛呢！
	at day11.ThreadDemo3$1.run(ThreadDemo3.java:14)
林： 干嘛呢！都破了相了

守护线程

Daemon 后台线程也称守护线程：当当前进程中“所有”“前台”线程死亡后，后台线程将被强制死亡（非自然死亡），无论是否在运行
1.守护线程，必须在启动线程钱调用
2.main方法也是靠线程运行的，且是一个前台线程。
3.正在运行的线程都是守护线程时，JVM退出

其他方法

static void yield(): 当前线程让出处理器（离开Running状态）即放弃当前时间片，主动进入Runnable状态等待。
wait/notify方法:这两个方法不是在线程Thread中定义的方法，这两个方法定义在Object中。两个方法的作用是协调线程工作的。wait()的作用是让当前线程进入等待（阻塞）状态，notify()是唤醒单个线程，而notifyAll()是唤醒所有的线程。
join(): 让"主线程"等待"子线程"结束之后才能继续运行。

---

yield()与wait()比较

• wait()是让线程由"运行状态"进入到"等待（阻塞）状态"，而yield()是让线程由"运行状态"进入到"就绪状态"
• wait()是会让线程释放它所持有对象的同步锁，而yield()方法不会释放锁。

synchronized关键字

多线程的同步机制对资源进行加锁，使得在同一个时间，只有一个线程可以进行操作。
当synchronized关键字修饰一个方法的时候，该方法叫做同步方法。当synchronized执行完成或者发生异常时，会自动释放锁。
如果一个对象有多个synchronized方法吗，某一时刻某个线程已经进入到了某个synchronized方法，那么在该方法没有执行完毕前，其他线程是无法访问该对象的任何synchronized方法的。
在java中，每一个对象有且仅有一个同步锁。这意味着，同步锁是依赖于对象而存在。
多个线程并发访问，也得一个线程执行完之后另一个线程才能执行：

• 静态方法 public synchronized static void fun(){}：其实锁的是类,类只有一个
• 代码块 synchronized(object){} 锁住的是object