线程的学习

一、线程的基本概念

进程： “独立的内存空间和系统资源

       进程是程序的一次动态执行过程，他对应了从代码加载 执行至执行完毕的一整个过程

特点：并发执行的，动态创建、动态消亡，进程是系统运行程序的基本单位

      每一个进程都有自己独立的一块空间 一组系统资源，每一个进程的内部数据和状态都是完全独立的
      进程至少包含一个线程 （主线程）

线程：CPU调度和分派的基本单位，进程中执行运算的最小单位，可完成一个独立的顺序控制流程

      真正在CPU上运行的是线程，一个线程可以创建一个线程也可以删除一个线程 -- 线程调度

特别说明下"进程的静态概念"
首先 一个.class文件，一个.exe文件，这个叫做一个进程。
程序的执行过程 ：
将代码块放进代码区，并没有执行，而是说明了一个进程已经准备开始了（已经产生了一个进程但是没有执行） 所以进程 其实是一个静态的概念，它本身就不能动。平常所说的进程的执行指的是进程里面主线程开始执行了，也就是main()方法开始执行了。进程是一个静态的概念，在我们机器里面实际上运行的都是线程。

CPU能够同时执行那么多程序吗？不是的，CPU的执行是这样的：CPU的速度很快，一秒钟可以算好几亿次，因此CPU把自己的时间分成一个个小时间片，我这个时间片执行你一会，下一个时间片执行他一会，再下一个时间片又执行其他人一会，虽然有几十个线程，但一样可以在很短的时间内把他们通通都执行一遍，但对我们人来说，CPU的执行速度太快了，因此看起来就像是在同时执行一样，但实际上在一个时间点上，CPU只有一个线程在运行。

学习线程首先要理清楚三个概念：

1.进程：进程是一个静态的概念
2.线程：一个进程里面有一个主线程叫main()方法，是一个程序里面的，一个进程里面不同的执行路径。
3.在同一个时间点上，一个CPU只能支持一个线程在执行。因为CPU运行的速度很快，因此我们看起来的感觉就像是多线程一样。

Windows操作系统是支持多线程的，它可以同时执行很多个线程，也支持多进程，因此Windows操作系统是支持多线程多进程的操作系统。Linux和Uinux也是支持多线程和多进程的操作系统。DOS就不是支持多线程和多进程了，它只支持单进程，在同一个时间点只能有一个进程在执行，这就叫单线程。

二、线程的创建和启动（这部分是摘抄）

在JAVA里面，JAVA的线程是通过java.lang.Thread类来实现的，每一个Thread对象代表一个新的线程。创建一个新线程出来有两种方法：
第一个是从Thread类继承，另一个是实现接口runnable。VM启动时会有一个由主方法(public static void main())所定义的线程，这个线程叫主线程。可以通过创建Thread的实例来创建新的线程。你只要new一个Thread对象，一个新的线程也就出现了。每个线程都是通过某个特定的Thread对象所对应的方法run()来完成其操作的，方法run()称为线程体。

范例1：使用实现Runnable接口创建和启动新线程

开辟一个新的线程来调用run方法

package cn.galc.test;

public class TestThread1{
    public static void main(String args[]){
        Runner1 r1 = new Runner1();       //这里new了一个线程类的对象出来
        //r1.run();           //这个称为方法调用，方法调用的执行是等run()方法执行完之后才会继续执行main()方法
        Thread t = new Thread(r1);           //要启动一个新的线程就必须new一个Thread对象出来
        //这里使用的是Thread(Runnable target) 这构造方法
        t.start();         //启动新开辟的线程，新线程执行的是run()方法，新线程与主线程会一起并行执行
        for(int i=0;i<10;i++){
            System.out.println("maintheod："+i);
        }
    }
}
/*定义一个类用来实现Runnable接口，实现Runnable接口就表示这个类是一个线程类*/
class Runner1 implements Runnable{
    public void run(){
        for(int i=0;i<10;i++){
            System.out.println("Runner1："+i);
        }
    }
}

多线程程序执行的过程如下所示：

不开辟新线程直接调用run方法

范例2：继承Thread类，并重写其run()方法创建和启动新的线程

package cn.galc.test;

/*线程创建与启动的第二种方法：定义Thread的子类并实现run()方法*/
public class TestThread2{
    public static void main(String args[]){
        Runner2 r2 = new Runner2();
        r2.start();    //调用start()方法启动新开辟的线程
        for(int i=0;i<=10;i++){
            System.out.println("mainMethod："+i);
        }
    }
}
/*Runner2类从Thread类继承
通过实例化Runner2类的一个对象就可以开辟一个新的线程
调用从Thread类继承来的start()方法就可以启动新开辟的线程*/
class Runner2 extends Thread{
    public void run(){           //重写run()方法的实现
        for(int i=0;i<=10;i++){
            System.out.println("Runner2："+i);
        }
    }
}

使用实现Runnable接口和继承Thread类这两种开辟新线程的方法的选择应该优先选择实现Runnable接口这种方式去开辟一个新的线程。因为接口的实现可以实现多个，而类的继承只能是单继承。因此在开辟新线程时能够使用Runnable接口就尽量不要使用从Thread类继承的方式来开辟新的线程。

总结：

创建线程有哪2种方式？
继承Thread类
实现Runnable接口
启动线程
start()方法

线程对象调用start()方法和调用run()方法的区别
run()：只有主线程一条执行路径
start()：多条执行路径，主线程和子线程并行交替执行

三、线程状态转换

线程的状态
线程的生命周期包括四个状态：新生状态，可运行状态，阻塞状态，死亡状态

新生状态：new出来之后没有start

可运行状态：调了start之后只是有了可运行的机会，准备抢占资源

阻塞状态：当一个运行时的线程出现某种原因不能继续运行时，则该线程进入阻塞状态，解决问题之后 又变成就绪状态 等待调度

死亡状态：一个线程的run方法执行完毕之后或者运行中出现异常时线程进入死亡状态

线程强制执行
线程名.join() ----------- 暂停当前线程 允许其他具有相同优先级单位线程获得运行机会
.join(long mills)毫秒数
.join(long mills,int nanos)毫秒数 纳秒数

线程的礼让（只提供了一种可能 不保证一定礼让）
join方法的使用范例：

package cn.galc.test;

public class TestThread4 {
    public static void main(String args[]) {
        MyThread2 thread2 = new MyThread2("mythread");
        // 在创建一个新的线程对象的同时给这个线程对象命名为mythread
        thread2.start();// 启动线程
        try {
            thread2.join();// 调用join()方法合并线程，将子线程mythread合并到主线程里面
            // 合并线程后，程序的执行的过程就相当于是方法的调用的执行过程
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        for (int i = 0; i <= 5; i++) {
            System.out.println("I am main Thread");
        }
    }
}

class MyThread2 extends Thread {
    MyThread2(String s) {
        super(s);
        /*
         * 使用super关键字调用父类的构造方法 
         * 父类Thread的其中一个构造方法：“public Thread(String name)” 
         * 通过这样的构造方法可以给新开辟的线程命名，便于管理线程
         */
    }

    public void run() {
        for (int i = 1; i <= 5; i++) {
            System.out.println("I am a\t" + getName());
            // 使用父类Thread里面定义的
            //public final String getName()，Returns this thread's name.
            try {
                sleep(1000);// 让子线程每执行一次就睡眠1秒钟
            } catch (InterruptedException e) {
                return;
            }
        }
    }
}

运行结果：

线程同步问题
当多个线程操作同一资源时（多个并发线程访问同一资源的同步代码块时） 将引发数据不安全问题，这时候就需要使用线程同步。

如何实现？
同一时刻只能有一个线程进入synchronized(this)代码块
当一个线程访问一个synchronized(this)代码块时 其他synchronized(this)同步代码块同样被锁定
当一个线程访问一个synchronized(this)同步代码块时，其他线程可以访问该资源的非synchronized(this)同步代码

synchronized是Java中的关键字，是一种同步锁。它修饰的对象有以下几种：
修饰一个代码块，被修饰的代码块称为同步语句块，其作用的范围是大括号{}括起来的代码，作用的对象是调用这个代码块的对象；
修饰一个方法，被修饰的方法称为同步方法，其作用的范围是整个方法，作用的对象是调用这个方法的对象；
修改一个静态的方法，其作用的范围是整个静态方法，作用的对象是这个类的所有对象；
修改一个类，其作用的范围是synchronized后面括号括起来的部分，作用主的对象是这个类的所有对象。

线程的休眠：

让线程暂时睡眠：指定时长，线程进入阻塞状态，睡眠时间过后线程会再进入可运行状态
【millis为休眠时长，以毫秒为单位】 【调用sleep()方法需处理InterruptedException异常】

例如：

public class Wait {
public static void bySec(long s) {
            for (int i = 0; i < s; i++) {
                            System.out.println(i + 1 + "秒");
            try {
                          Thread.sleep(1000); 
                  } catch (InterruptedException e) {
                          e.printStackTrace();

public static void main(String[] args) {
 
System.out.println("*****主线程开始休眠*****");
                     Wait.bysec(5); //让主线程休眠5秒
 
System.out.println("*****主线程休眠结束*****"); }
                    Thread.sleep(1000)：线程休眠1秒

sleep方法的应用范例：

package cn.galc.test;

import java.util.*;

public class TestThread3 {
    public static void main(String args[]){
        MyThread thread = new MyThread();
        thread.start();//调用start()方法启动新开辟的线程
        try {
            /*Thread.sleep(10000);
            sleep()方法是在Thread类里面声明的一个静态方法，因此可以使用Thread.sleep()的格式进行调用
            */
            /*MyThread.sleep(10000);
            MyThread类继承了Thread类，自然也继承了sleep()方法，所以也可以使用MyThread.sleep()的格式进行调用
            */
            /*静态方法的调用可以直接使用“类名.静态方法名”
              或者“对象的引用.静态方法名”的方式来调用*/
            MyThread.sleep(10000);
            System.out.println("主线程睡眠了10秒种后再次启动了");
            //在main()方法里面调用另外一个类的静态方法时，需要使用“静态方法所在的类.静态方法名”这种方式来调用
            /*
            所以这里是让主线程睡眠10秒种
            在哪个线程里面调用了sleep()方法就让哪个线程睡眠，所以现在是主线程睡眠了。
            */
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        //thread.interrupt();//使用interrupt()方法去结束掉一个线程的执行并不是一个很好的做法
        thread.flag=false;//改变循环条件，结束死循环
        /**
         * 当发生InterruptedException时，直接把循环的条件设置为false即可退出死循环，
         * 继而结束掉子线程的执行，这是一种比较好的结束子线程的做法
         */
        /**
         * 调用interrupt()方法把正在运行的线程打断
        相当于是主线程一盆凉水泼上去把正在执行分线程打断了
        分线程被打断之后就会抛InterruptedException异常，这样就会执行return语句返回，结束掉线程的执行
        所以这里的分线程在执行完10秒钟之后就结束掉了线程的执行
         */
    }
}

class MyThread extends Thread {
    boolean flag = true;// 定义一个标记，用来控制循环的条件

    public void run() {
        /*
         * 注意：这里不能在run()方法的后面直接写throw Exception来抛异常， 
         * 因为现在是要重写从Thread类继承而来的run()方法,重写方法不能抛出比被重写的方法的不同的异常。
         *  所以这里只能写try……catch()来捕获异常
         */
        while (flag) {
            System.out.println("==========" + new Date().toLocaleString() + "===========");
            try {
                /*
                 * 静态方法的调用格式一般为“类名.方法名”的格式去调用 在本类中声明的静态方法时调用时直接写静态方法名即可。 当然使用“类名.方法名”的格式去调用也是没有错的
                 */
                // MyThread.sleep(1000);//使用“类名.方法名”的格式去调用属于本类的静态方法
                sleep(1000);//睡眠的时如果被打断就会抛出InterruptedException异常
                // 这里是让这个新开辟的线程每隔一秒睡眠一次，然后睡眠一秒钟后再次启动该线程
                // 这里在一个死循环里面每隔一秒启动一次线程，每个一秒打印出当前的系统时间
            } catch (InterruptedException e) {
                /*
                 * 睡眠的时一盘冷水泼过来就有可能会打断睡眠 
                 * 因此让正在运行线程被一些意外的原因中断的时候有可能会抛被打扰中断(InterruptedException)的异常
                 */
                return;
                // 线程被中断后就返回，相当于是结束线程
            }
        }
    }
}

运行结果：

线程安全的类型

线程安全 方法同步 效率低 适合多线程并发共享资源

非线程安全 方法不同步 效率高 适合单线程

实现线程间通信
wait();调用wait方法会挂起当前线程 并释放共享资源的锁
notify():调用任意对象的notify方法会在因调用该对象的wait方法而阻塞的线程中随机选择一个线程解除阻塞，但要等到获得锁后才可真正的执行线程
notifyAll() 调用了该方法会将因调用该对象的wait方法而阻塞的所有线程一次性全部接触阻塞。

目前就是辣嘛多了 ， 后面 学习了在继续更吧~~