多线程基础

java多线程学习

此文档主要讲解java中多线程的使用方法、线程同步、线程数据传递、线程状态及相应的一些线程函数用法、概述等。

操作系统中线程和进程的区别：
    
    进程：每个进程都有独立的代码和数据空间（进程上下文），进程间的切换会有较大的开销，一个进程可以包含1~N个线程。（进程是资源分配的最小单位）

    线程：同一类线程共享代码和数据空间，每个线程有独立的运行栈和程序计数器（PC），线程切换开销小。（线程是CPU调度的最小单位)

    线程和进程一样分为5个阶段：创建、就绪、运行、阻塞、终止

    多进程是指操作系统能同时运行多个任务（程序）

    多线程是指在同一程序中有多个顺序流在执行。

    在java中要想实现多线程，有两种手段，一个继承Thread类型，一个实现Runnable接口。（还有一种是实现Callable接口，并与Future,线程池结合使用）

一、扩展javalangThread类
    
    这里继承Thread类的方法是比较常用的一种，如果说你只是想起一条线程，没有什么其他特殊的要求，那么可以使用Thread
    
        package MyThread;

        public class ThreadT extends Thread{
            
            private String name ;
            
            public ThreadT(String name){
                this.name = name;
            }
            
            public void run(){
                for (int i = 0 ; i < 5; i++){
                    System.out.println(name + "运行   ：" + i); 
                    try {
                        sleep((long) (Math.random() * 10));
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                } 
            }
            
            public static void main(String[] args) {
                ThreadT T1 = new ThreadT("A");
                ThreadT T2 = new ThreadT("B");
                T1.start();
                T2.start();
            }
        }
        
        运行结果：
        A运行   ：0
        B运行   ：0
        A运行   ：1
        B运行   ：1
        A运行   ：2
        B运行   ：2
        A运行   ：3
        B运行   ：3
        B运行   ：4
        A运行   ：4
        再次运行：
        A运行   ：0
        B运行   ：0
        B运行   ：1
        A运行   ：1
        B运行   ：2
        A运行   ：2
        B运行   ：3
        B运行   ：4
        A运行   ：3
        A运行   ：4
    说明：
    程序启动运行main时候，java虚拟机启动一个进程，主线程main在main()调用时被创建，随着调用的两个对象的start方法，另外两个线程也启动了，这样，整
应用就在多线程下运行。

    注意:start()方法调用后并没有立即执行多线程代码，而是使得该线程变为可运行状态（Runnable），什么时候运行是由操作系统决定的。
    从程序运行的结果可以发现，多线程程序是乱序执行。因此，只有乱序执行的代码才有必要设计为多线程执行的机会。
    Thread.sleep()方法调用目的是不让当前线程独自霸占该进程所获取的CPU资源，一流出一定时间给其他线程执行的机会。
    所有的多线程代码执行顺序都是不确定的，每次执行的结果都是随机的。
    
    同一个线程的start()方法是不能重复调用的，不然后抛出：Exception in thread "main" java.lang.IllegalThreadStateException 

    
二、实现javalangRunnable接口
    
    采用Runnable也是非常常见的一种，我们只需要重写run方法即可。
    package MyThread;

    public class ThreadT implements Runnable{
        
        private String name ;
        
        public ThreadT(String name){
            this.name = name;
        }
        
        @Override
        public void run() {
            for(int i = 0 ; i < 5; i++){
                System.out.println(name + "运行："+ i);
                try {
                    Thread.sleep((long)Math.random() * 10);
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            } 
        } 
        
        public static void main(String[] args) { 
            new Thread(new ThreadT("A")).start(); 
            new Thread(new ThreadT("B")).start(); 
        }  
    }
    
    运行结果：
    A运行：0
    B运行：0
    B运行：1
    A运行：1
    B运行：2
    A运行：2
    B运行：3
    A运行：3
    B运行：4
    A运行：4
    再次运行：
    A运行：0
    A运行：1
    B运行：0
    B运行：1
    A运行：2
    B运行：2
    A运行：3
    B运行：3
    A运行：4
    B运行：4
    
    说明：
    ThreadT类通过实现Runnable接口，使得该类有了多线程类的特征。run()方法是多线程程序的一个约定。所有的多线程代码都在run()方法里面。Thread类实际
也是实现了Runnable接口的类。
    在启动多线程的时候，需要先通过Thread类的构造方法Thread(Runnable target)构造出对象，然后调用Thread对象的start()方法来运行多线程代码。
    实际上所有的多线程代码都是通过运行Thread的start()方法来运行的。因此，不管是扩展Thread类还是实现Runnable接口来实现多线程，最终还是通过Thread
的对象的API来控制线程的，熟悉Thread类的API是进行多线程编程的基础

三、Thread和Runnable的区别
    
    如果继承Thread，则不适合资源共享。但是如果实现了Runnable接口的话，则很容易的实现资源共享
    
    总结：
    实现Runnable接口比继承Thread类所具有的优势：
    
    1、适合多个相同的程序代码的线程去处理同一个资源
    2、可以避免java中单继承的限制
    3、增加程序的健壮性，代码可以被多个线程共享，代码和数据独立
    4、线程池只能放入Runnable或callable类线程，不能直接方法继承Thread的类型
    
    main方法其实也是一个线程，在java中所有的线程都是同事启动的，至于什么时候，那个先执行，完全看谁先得到CPU的资源。
    
    在java中，每次程序运行至少2个线程。一个是main线程，一个是垃圾收集线程。因为每当使用java命令执行一个类的时候，实际上都会启动一个jvm，每一个
jvm的启动，就是在操作系统中启动一个进程。
    
    
四、线程状态转化
    下面的这个图片非常重要
    
    图片
    

    1、新建状态(new):新创建了一个线程对象
    2、就绪状态(Runnable):线程对象创建后，其他线程调用该对象的start()方法。该状态的线程位于可运行线程池中，变得可运行，等待获取CPU的使用权
    3、运行状态(Running):就绪状态的线程获取了CPU，执行程序代码
    4、阻塞状态(Blocked):阻塞状态是线程因为某种原因放弃CPU使用权，暂时停止运行。直到线程进入就绪状态，才有机会转到运行状态。阻塞的情况分三种：
        一、等待阻塞：运行的线程执行wait()方法，jvm会把该线程放入等待池中。(wait会释放持有的锁)
        二、同步阻塞：运行的线程在获取对象的同步锁时，若该同步锁被别的线程占用，则JVM会把该线程放入锁池中。    三、其它阻塞：运行的线程执行sleep()或join()方法，或者发出了I/O请求时，JVM会把该线程置为阻塞状态。当sleep()状态超时，join()等待线程终止或者超时，或者I/O处理完毕时，线程重新转入就绪状态。(注意，sleep是不会释放持有的锁)、
    5、死亡状态(Dead)：线程执行完了或者因异常退出了run()方法，该线程结束生命周期。    
    
五、线程调度
    
    线程调度
    1、调整线程优先级：Java线程有优先级，优先级高的线程会获得较多的执行机会
    
    Java线程的优先级用整数表示，取值范围是1~10,Thread类有一下三种静态常量：
    static int MAX_PRIORITY
        线程可以具有的最高优先级，取值为10
    static int MIN_PRIORITY
        线程可以具有的最低优先级，取值为1
    static int NORM_PRIOPITY
        分配给线程的默认优先级，取值为5
        
    Thread类的setPriority()和getPriority()方法分别用来设置和获取线程的优先级
    
    每个线程都有默认的优先级。主线程的默认优先级为Thread.NORM_PRIORITY。
    
    线程的优先级有继承关系，比如A线程中创建了B线程，那么B将和A具有相同优先级
    Jvm提供了10个线程优先级，但与常用的操作系统都不能很好的映射。如果希望程序能够移植到各个操作系统中，应该仅仅使用Thread类的静态常量作为优先级
这样能保证同样的优先级采用了同样的调度方式。

    2、线程睡眠：Thread.sleep(long millis)方法，使线程换到阻塞状态。millis参数设定睡眠的时间，以毫秒为单位。当睡眠结束后，就转为就绪(Runnable)
状态。sleep()平台移植性好。

    3、线程等待：Object类中的wait()方法，导致当前的线程等待，直到其他线程调用此对象notify()方法或notifyAll()唤醒方法。这两个唤醒方法也是Object
类中的方法，行为等价于调用wait(o).

    4、线程让步：Thread.yield()方法，暂停当前正在执行的线程对象，把执行机会让给相同或者更高优先级的线程。
    
    5、线程加入：join()方法，等待其他线程终止。在当前线程中调用另一个线程的join()方法，则当前线程转入阻塞状态，直到另一个进程运行结束，当前线程
再由阻塞转为就绪状态

    6、线程唤醒：Object类型的notify()方法，唤醒在此对象监视器上等待的单个线程。如果所有线程都在此对象上等待，则会选择唤醒其中一个线程。选择是任
意的，并在对实现做出决定时发生。线程通过调用其中一个wait方法，在对象的监视器上等待。直到当前线程放弃此对象的锁定，才能继续执行被唤醒的线程。被
唤醒的线程将以常规方式与在该对象上主动同步的其他所有线程进行竞争；
    
六、常用函数说明

    sleep(long millis)：在指定的毫秒数内让当前正在执行的线程休眠
    
    join()：指在等待t线程终止

    1、使用方法
    
    join是Thread类的一个方法，启动线程后直接调用，即join()的作用是：等待该线程终止，这里需要理解的就是主线程等待子线程终止。也就是在子线程调用
了join()方法后面的代码，只能等到子线程结束了才能执行 
    
    2、为什么要用join方法
    
    很多情况下，主线程生成并启动了子线程，如果子线程里需要进行大量的耗时的运算，主线程往往将于子线程之前结束，但是如果主线程处理完其他的事务后
需要用到子线程的处理结果，也就是主线程需要等待子线程执行完成之后再结束，这个时候就要用到join()方法了。

    3、yield()：暂停当前真在执行的线程对象，并执行其它线程
    
    Thread.yield()方法作用是：暂停当前真在执行的线程对象，并执行其他线程。
    yield()应该做的是让当前运行线程回到可运行状态，以允许具有相同优先级的其他线程获得运行机会。因此，使用yield()的目的是让相同优先级的线程之间
能适当的轮转执行。但是，实际中无法保证yield()达到让步目的，因为让步的线程还可能被线程调度程序再次选中。
    
    yield()从未导致线程转到等待/睡眠/阻塞状态。在大多数情况下，yielld()将导致线程从运行状态转到可运行状态，但有可能么有效果。
    
    
    sleep()和yield()的区别：sleep()使当前线程进入睡眠状态，所有在执行sleep()的线程在指定的时间内是不会被执行的。yield()只是使当前线程重新回到可
执行状态，所以执行yield()的线程有可能在进入到可执行状态后马上有被执行。
    sleep方法使当前运行中的线程睡眠一段时间，进入不可运行状态，这段时间的长短是有程序设定的，yield方法使当前线程让出CPU占有权，但让出的时间是不
可设定的。实际上，yield()方法对应了如下操作：先检测当前是否有相同的优先级的线程处于可运行状态，如果有，则把CPU的占有权交给此线程，否则，继续执行原来的线程。所以yield()方法称为"退让"，他把运行机会让给了同等优先级的其他线程
    另外，sleep方法发允许较低优先级的线程获得运行机会，但yield()方法执行时，当前线程仍然处在可运行状态，所以，不可能把CPU的占有权让给较低级别的
线程。在一个运行系统中，如果较高的优先级的线程调用了sleep方法，又没有受到I\O阻塞，那么，较低优先级线程只能等待所有较高优先级的线程运行结束之后才能运行。

    4、setPriority()：更改线程的优先级
        MIN_PRIORITY = 1
        NORM_PRIORITY = 5
        MAX_PRIORITY = 10
    用法：
    Thread1 t1 = new Thread("T1")
    Thread1 t2 = new Thread("T2")
    t1.setPriority(Thread.MAX_PRIORITY);
    t2.setPriority(Thread.MIN_PRIORITY);

    5、interrupt():向线程发送一个中断信号，让线程在无限等待时能够抛出异常，但是如果你吃掉了这个异常，那么这个线程还是会中断
    
    6、wait()
    Obj.wait()和Obj.notify()必须要与synchronized(Obj)一起使用，也就是wait,与notify是针对已经获取了Obj锁进行操作，从语法角度来说就是Ojb.wait(),
Obj.notify必须在synchronized(Obj){....}语句块内。从功能块上来说wait就是说线程在获取对象锁后，主动释放对象锁，同时本线程休眠。直到有其他线程调用
对象的notify()唤醒该线程，才能继续获取对象锁，并继续执行。相应的notify()就是对象锁的唤醒操作。但有一点需要注意的是notify调用后，并不是马上就释放对象锁的，而是在相应的synchronized(){}语句块执行结束，自动释放锁后，JVM会在wait()对象锁的线程中随机选取一线程，赋予其对象锁，唤醒线程，继续执行。这样就提供了线程间同步、唤醒的操作。Thread.sleep()与Object.wait()二者都可以暂停当前线程，释放CPU控制权，主要的区别在于Object.wait()在释放
CPU同时，释放了对象锁的控制。

    代码：
    package MyThread;

    public class MyThreadPrinter implements Runnable{
        
        private String name;
        private Object  prev;
        private Object  self; 

        public MyThreadPrinter(String name, Object prev, Object self) {
            super();
            this.name = name;
            this.prev = prev;
            this.self = self;
        } 

        @Override
        public void run() {
            int count = 10;
            while(count > 0 ){
                synchronized (prev){
                    synchronized (self){
                        System.out.print(name); 
                        count --;
                        self.notify(); 
                    }
                    try {
                        prev.wait();
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                }
            }
            
        }
        public static void main(String[] args) throws Exception{
            Object a = new Object();     
            Object b = new Object();     
            Object c = new Object(); 
            MyThreadPrinter pa = new MyThreadPrinter("A", c, a);     
            MyThreadPrinter pb = new MyThreadPrinter("B", a, b);     
            MyThreadPrinter pc = new MyThreadPrinter("C", b, c);     
            new Thread(pa).start();  
            Thread.sleep(100);  //确保按顺序A、B、C执行  
            new Thread(pb).start();  
            Thread.sleep(100);    
            new Thread(pc).start();     
            Thread.sleep(100);
        }
    }
    
    结果：ABCABCABCABCABCABCABCABCABCABC
    
    wait和sleep区别：
    共同点：
    1、他们都在多线程的环境下，都可以在程序的调用处阻塞指定的毫秒数，并返回。
    2、wait()和sleep()都可以通过interrupt()方法打断线程的暂停状态，从而使线程立刻抛出InterruptedException
    
    如果线程A希望立即结束线程B，则可以对线程B对应的Thread实例调用interrupt方法。如果此刻线程B正在wait/sleep/join,则线程B会立刻抛出
InterruptedException，在catch(){}中直接return即可安全的结束线程
    需要注意的是，InterruptedException是线程自己从内部抛出的，并不是interrupt()方法抛出的。对某一线程调用interrupt()时，如果该线程正在执行普通
的代码，那么该线程不会抛出InterruptedException。但是，一旦该线程进入到wait()/sleep()/join()后，就会立刻抛出InterruptedException

    不同点：
    1、 Thread类的方法：sleep()，yield等等
        Object的方法：wait(),notify()
    2、每个对象都有一个锁来控制同步访问。Synchronized关键字可以和对象的锁交互，来实现线程的同步
       sleep方法没有释放锁，而wait方法释放了锁，使得其他线程可以使用同步控制块或者方法。
    3、wait,notify和notifyAll只能在同步控制方法或者同步控制块里面使用，而sleep可以在任何地方使用
    4、sleep必须捕获异常，而wait，notify和notifyAll不需要捕获异常
        所以sleep()和wait()方法的最大区别是：
            sleep()睡眠时，保持对象锁，仍然占有该锁，而wait()暂停时，释放对象锁。但是wait()和sleep()都可以通过interrupt()方法打断线程的暂停状态
        从而使线程立刻抛出InterruptedException
        
        sleep()方法：sleep()是Thread类的static(静态)的方法；因此他不能改变对象的机锁，所以当在一个Synchronized块中调用sleep()方法时，线程虽然休
    眠了，但是对象的机锁并没有被释放，其他线程无法方位这个对象
        在sleep()休眠时间到了之后，该线程不一定会立即执行，这是因为其他线程可能正在运行而且没有被调度为放弃执行，除非此线程具有更高的优先级
        wait()方法：wait()方法是Object类里的方法；当一个线程执行到wait()方法时，他就进入到一个和该对象相关的等待池中，同时失去了对象的机锁超时
    时间；其他线程可以访问；
        wait()使用notify或者notifyAll或者指定睡眠时间来唤醒当前等待池中的线程。
        
        
七、常见线程名词解析
    
    主线程：JVM调用程序main()所产生的线程
    当前线程：这个容易混淆的概念。一般指通过Thread.currentThread()来获取的进程
    后台线程：指为其他线程提供服务的线程，也称为守护线程。JVM的来及回收线程就是一个后台线程。
    前台线程：是指接受后台线程服务的线程，其实前台后台线程是联系在一起，就像傀儡和模糊操纵者一样的关系。傀儡是前台线程，幕后操纵者是后台线程。
由前台线程创建的线程默认也是前台线程。可以通过isDaemon()和setDaemon()方法来判断和设置一个线程是否为后台线程。

    线程类的一些常用方法：
    sleep():强迫一个线程睡眠N毫秒
    isAlive():判断一个线程是否存活
    join():等待线程终止
    activeCount()：程序中活跃的线程数
    enumerate():枚举程序中的线程
    currentThread():得到当前线程
    isDaemon():一个线程是否为守护线程
    setDaemon():设置一个线程为守护线程。(用户线程核守护线程的区别在于，是否等待主线程依赖于主线程结束而结束)
    setName():为线程设置一个名称
    wait():强迫一个线程等待
    notify():通知一个线程继续运行
    setPriority():设置一个线程的优先级
    
八、线程同步

    1、synchronized关键字的作用域有两种：
        1) 是某个对象实例内，synchronized aMethod(){}可以防止多个线程同时访问这个对象的synchronized方法(如果一个对象有多个synchronized方法，只
    要一个线程访问其中的一个synchronized方法，其它线程不能同时访问这个对象中任何一个synchronized方法)。这是，不同的对象实例的synchronized方法是
    不向干扰的。也就是说，其它线程照样可以同时访问相同类的另一个对象实例中的synchronized方法；
        2)是某个类的范围，synchronized static aStaticMethod{}防止多个线程同时访问这个类中的synchronized static方法。它可以对类的所有对象实例起
    作用。
    
    2、除了方法前用synchronized关键字，synchronized关键字还可以用在方法中的某个区块中，表示只对这个区块的资源实行互斥访问。用法：
        synchronized(this){代码区}，它的作用域是当前对象。
        
    3、synchronized关键字是不能继承的
    
    线程同步的目的是为了保护多个线程反问一个资源时对资源的破坏
    线程同步方法是通过锁来实现，每个对象都有且仅有一个锁，这个锁与一个特定的对象关联，线程一旦获取了对象锁，其他访问该对象的线程就无法再访问该
对象的其他非同步方法。
    对于惊天同步方法，锁时针对这个类的，锁对象时改类的class对象。静态和非静态方法的锁互不干预。一个线程获得锁，当在一个同步方法中访问另外对象上
的方法时，会获取这两个对象锁。
    对于同步，要时刻清醒在那个对象上同步，这是关键
    编写线程安全的类，需要时刻注意对多个线程竞争访问资源的逻辑和安全做成正确的判断，对原子操作做出分析，并保证原子操作期间别的线程无法访问竞争
资源
    当多个线程等待一个对象锁时，没有获取到锁的线程将发生阻塞
    死锁是线程间相互等待锁造成的，在实际中发生概率非常小。

九、线程数据传递

    在传统的同步开发模式下，当我们调用一个函数时，通过这个函数的参数将数据传入，并通过这个函数的返回值来返回最终的计算结果。但在多线程的异步开
发模式下，数据的传递、返回和同步开发模式有很大的区别。由于线程的运行和结束是不可预料的，因此，在传递和返回数据时就无法象函数一样通过参数和
return 语句来返回数据。
    
    1、通过构造方法传递数据
        在创建线程时，必须要建立一个Thread类或其子类的实例。因此，我们不能想到在调用start方法之前通过线程类的构造方法将数据传入线程。并将传入的
    数据使用类变量保存起来，以便线程使用；

    package MyThread;

    public class MyThread4 extends Thread {
        private String name;

        public MyThread4(String name) {
            super();
            this.name = name;
        }
        public void run(){
            System.out.println("hello "+name);
        }
        public static void main(String[] args) {
            Thread thread4 = new MyThread4("world");
            thread4.start();
        }
    }

    由于这种方法是在创建线程对象的同时传递数据的，因此，在线程运行之前这些数据就已经到位了，这样就不会造成数据在线程运行后才传入的现象。如果要
传递更复杂的数据，可以使用集合、类等数据构造。使用构造方法来传递数据虽然比较安全，单如果要传递的数据比较多时，就会造成很多不便。由于Java没有默认参数，要想实现类似默认参数的效果，就待使用重载，这样不但使构造方法本身过于复杂，又会使构造方法在数量上大增。因此，要避免这种情况，就待通过类方法或类变量来传递数据。

    2、通过变量和方法传递数据
    
    向对象中传入数据一般有两次机会，第一次机会是在建立对象时通过构造方法将数据传入，另外一次机会就是在类中定义一系列的public的方法或变量。然后
在建立完对象后，通过的对象实例逐个复制。
    
    package MyThread;

    public class MyThread4 implements Runnable {
        private String name;
        
        public void setName(String name) {
            this.name = name;
        } 
        public void run(){
            System.out.println("hello "+name);
        }
        public static void main(String[] args) {
            MyThread4 myThread4 = new MyThread4();
            myThread4.setName("world");
            Thread thread = new Thread(myThread4);
            thread.start();
        }
    }

    3、通过回调函数传递数据
        
        上面讨论的两种向线程种传递数据的方法是最常用的。单这两种方法都是main方法中主动将数据传入线程类的。这对于线程来说，是被动接收这些数据的
    然后，在有些引用中需要再线程运行的过程中动态的获取数据。
    
    package MyThread;

    public class Data {
        public int value = 0;
    }

    package MyThread;

    public class Work {
        public void process(Data data, Integer... numbers){
            for(int n : numbers){ 
                data.value +=n;
            }
        }
    }

    package MyThread;

    import java.util.Random;

    public class MyThread4 extends Thread {
        private Work work;
        public MyThread4(Work work){
            this.work = work;
        } 
         
        public void run() {
            Random random = new Random();
            Data data = new Data();
            int n1 = random.nextInt(1000);
            int n2 = random.nextInt(2000);
            int n3 = random.nextInt(3000);
            work.process(data, n1,n2,n3);
            System.out.println(data.value); 
        }
        public static void main(String[] args) {
            Thread thread = new MyThread4(new Work());  
            thread.start();
        }
         
    }