黑马程序员----Java多线程

                                                     ------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------

多线程

一、概述

           了解多线程前我们先明确一下线程的概念。

           进程：是一个正在执行中的程序。每一个进程执行都有一个执行顺序，该顺序是一个执行路径或者说控制单元。

           线程：就是进程中的一个独立的控制单元，线程控制着进程的执行。由此可知，一个进程至少有一个线程。

           Java虚拟机启动时会有一个进程java.exe。该进程中至少有一个线程负责java程序的执行。而且这个程序运行的代码存在于与main方法中，这个线程称之为主线程。另外其实jvm启动不只一个线程，还有一个处理垃圾回收机制的线程，因为当产生垃圾时，主线程在执行自己的功能，不能通知去执行垃圾回收所以会有一个线程执行垃圾回收。

            多线程存在意义：可以使多部代码同时运行。

二、线程的创建方式

创建线程的第一种方式：继承Thread类，创建步骤;

            1.创建类继承Thread类。

            2.复写Thread类中的run方法。

            3.调用线程中的start方法，这个方法得作用启动线程，调用run方法。

下面就是一个简单的线程创建示例：

package xiaobing.xiancheng;class Demo extends Thread //创建线程{public void run(){for(int x=0;x<40;x++)System.out.println("demo run---"+x);}}public class ThreadDemo01 {public static void main(String[] arrgs){Demo d=new Demo();//创建线程实例d.start();//启动线程for(int x=0;x<60;x++){System.out.println("Hello World---"+x);}}}

以上示例我们发现结果不规则，这个其实是2个线程在同时获取Cpu的执行权，哪个获取到了，哪个线程就执行。 在某一个时刻，只能有一个程序在运行（多核除外）。

            为什要覆盖run方法呢？因为Thread类用于描述线程，run方法中就存储了线程运行的代码。

线程的运行状态：

               被创建，调用start()方法。

               运行，此时该线程具备执行资格和执行权。

               冻结，等待被唤醒(wait)，sleep时间到，此时已经放弃了执行资格。

                消亡，stop(),run方法结束。

特殊的状态：临时阻塞状态，具备运行资格，但没有执行权，冻结结束后先进入这个状态。

线程名称的获取，通过Thread类中的获取方法，Thread.currentThread.getName()，可以防发现线程都有自己默认的名称为Thread-编号，从0开始。

 创建线程的第二种的方式，实现Runable接口，创建步骤如下：

                 1.定义类实现Runnable接口

                 2.覆盖Runnble中的run方法，存放运行的线程代码。

                 3.通过Thread类建立线程对象

                 4.将Runnable接口的子类对象作为实际参数传递给Thread类中的构造函数。这是因为run所属的对象时接口的子类对象，所以要让线程去指定对象的run方法。

                 5.调用Thread类的start方法开启线程并调用Runnable接口的子类run方法

实现Runnble接口的好处避免了单继承的局限性，类可以多实现而不能多继承。

下面是一个简单的买票例子：

package xiaobing.xiancheng;/* * 需求：简单的买票程序 * 多个窗口同时买票 *  */class Ticket implements Runnable//extends Thread{private static int tick=100;public void run(){while(true){if(tick>0){System.out.println(Thread.currentThread().getName()+"...sale:"+tick--);}}}}public class ThreaDemo03 {public static void main(String[] args){Ticket t=new Ticket();//此时并没有创建线程Thread t1=new Thread(t);//将实现接口的类作为参数传入Thread类的构造函数中以便调用start方法 Thread t2=new Thread(t);Thread t3=new Thread(t);Thread t4=new Thread(t);t1.start();t2.start();t3.start();t4.start();//启动Start方法/* * Ticket t1=new Ticket(); *Ticket t2=new Ticket();Ticket t3=new Ticket();Ticket t4=new Ticket();t1.start();t2.start();t3.start();t4.start();*/}}

安全问题：

 以上例子我们发现如果在执行方法假如sleep时间时居然卖出了0，-1，-2的票，这时程序就出现了安全问题 。

这是由于当多条语句在操作同一个线程共享数据时，一个 线程对多条语句只执行了一部分。还没有执行完，另一个线程参与进来，导致共享数据的错误。

解决办法：对操作共享数据的语句只能让一个线程都执行完，其他线程不可以参与进行。这时就用到同步代码块解决，格式如下：

synchronized(对象）

{

        需要被同步的代码（哪些语句在操作共享数据）

}

同步的前提：必须要有两个或以上的线程，必须是多个线程使用同一个锁。

同步的弊端：操作数据需在进行一步判断，所以比较耗费系统资源。

同步锁所使用对象的描述验证：

package xiaobing.xiancheng;/* * 验证同步函数的锁是this! * 函数需要被对象调用，那么函数都有一个所属对象引用，就是this * 验证方式：使用两个线程来卖票 * 一个线程在同步代码块中，一个在同步函数中，都执行卖票动作，如果正常同步 * 那卖票不会出现问题 * 发现卖出了0号票 * 将obj改为this后运行正常，证明锁为this * 》》》注意当函数被静态描述后同步函数的锁为程序的字节码文件Class对象。类名.Class */class Ticket1 implements Runnable{private static int tick=1000;Object obj=new Object();boolean flag=true;//用于判别进入同步函数还是同步代码块public void run(){if(flag){while(true){synchronized(this)//定义同步代码块{if(tick>0){try{Thread.sleep(10);}catch(Exception e){}System.out.println(Thread.currentThread().getName()+"...code:"+tick--);}}}}elsewhile(true)show();}public synchronized void show()//同步函数{if(tick>0){try{Thread.sleep(10);}catch(Exception e){}System.out.println(Thread.currentThread().getName()+"...show:"+tick--);}}}public class ThreadDemo05 {public static void main(String[] args){Ticket1 t=new Ticket1();//此时并没有创建线程Thread t1=new Thread(t);//将实现接口的类作为参数传入Thread类的构造函数中以便调用start方法 Thread t2=new Thread(t);//Thread t3=new Thread(t);//Thread t4=new Thread(t);t1.start();try{Thread.sleep(10);}catch(Exception e){}//让第一个线程sleep运行第二个线程t.flag=false;//用于切换t2.start();//t3.start();//t4.start();}}

知识点：单例设计模式-懒汉式多线程注意：

package xiaobing.xiancheng;/* * 单例设计模式 * 当多个程序并发调用getInstance * 那么就有多个线程操作s，这就会出现创造多余的对象，不能保证内存的唯一性，就会产生安全隐患 * 这时可以采取同步函数 * 但是但是每个线程想要获取对象会判断锁的存在，程序会显得低效 * 这时可以用双重判断解决这个问题 *///懒汉式设计模式class Single{private static Single s=null;private Single(){}public static /*synchronized*/Single getInstance(){if(s==null){synchronized(Single.class){if(s==null)s=new Single();}}return s;}}public class ThreadDemo06 {}

三、线程间通信

            线程通信其实就是多个线程操作同一个资源，但是操作的动作不同

实现方法：

        将操作的资源封装为对象，同时执行的任务也封装为对象，实现多线程是同步锁使用唯一的资源对象就可以了。

等待唤醒机制：

方法：wait()将同步中的线程处于冻结状态，放弃执行权和资格 ，notify()唤醒正在等待的线程notifyAll唤醒所有线程。

实例：

package xiaobing.xiancheng;/* * wait * notify() * nitifyAll() * 这些方法都是用在同步中，因为要对持有监视器（(锁)的线程操作 * 所以要使用在同步中，因为只有同步才具有锁 * 为什么操作线程的方法在Object类中呢？ * 因为这些方法在操作同步中的线程时，都必须要标示所操作线程只有的锁 * 只有同一个锁上的被等待线程才能被同一个锁上的notify锁唤醒，不可以 * 对不同锁中的线程进行唤醒 * 也就是说，等待和唤醒必须是同一个锁，而锁可以使任意对象，所以 * 可以被任意对象调用的方法定义在Object类中。 */class Res//建立操作资源{private String name;private String sex;boolean flag=false;public synchronized void set(String name,String sex)//将同步数据用同步函数描述{if(flag)try{this.wait();}catch(Exception e){}//为false时程序进入等待this.name=name;this.sex=sex;flag=true;//改变状态是其他的线程唤醒        this.notify();}public synchronized void out(){if(!flag)try{this.wait();}catch(Exception e){}System.out.println(name+"...."+sex);flag=true;        this.notify();}}class Input implements Runnable{private Res r;//Object obj=new Object();Input(Res r){this.r=r;}public void run(){int x=0;while(true){if(x==0)r.set("mike", "man");elser.set("丽丽", "女");x=(x+1)%2;}}}class Output implements Runnable{private Res r;//Object obj=new Object();Output(Res r){this.r=r;}public void run(){while(true){r.out();}}}class ThreadDemo07 {public static void main(String[] args){Res r=new Res();new Thread(new Input(r)).start();new Thread(new Output(r)).start();/*Input in=new Input(r);Output out=new Output(r);Thread t1=new Thread(in);Thread t2=new Thread(out);t1.start();t2.start();*/}

线程中的其他方法：

线程的停止：通过stop方法就可以停止线程。这个方式过时了。

停止线程：原理就是：就是结束run方法。

怎么结束run方法？一般run方法里肯定定义循环。所以只要结束循环即可。

第一种方式：定义循环的结束标记。

第二种方式：如果线程处于了冻结状态，是不可能读到标记的，这时就需要通过Thread类中的interrupt方法，将其冻结状态强制清除。让线程恢复具备执行资格的状态，让线程可以读到标记，并结束。

 

java.lang.Thread 

interrupt()：中断线程。

setPriority(int newPriority)：更改线程的优先级。

getPriority()：返回线程的优先级。

toString()：返回该线程的字符串表示形式，包括线程名称、优先级和线程组。

Thread.yield()：暂停当前正在执行的线程对象，并执行其他线程。

setDaemon(true)：将该线程标记为守护线程或用户线程。将该线程标记为守护线程或用户线程。当正在运行的线程都是守护线程时，Jvm退出。该方法必须在启动线程前调用