Java基础——多线程

多线程

进程：正在运行的程序，一个进程中至少有一个线程

线程：线程就是进程中的一个控制单元，线程控制着进程的执行

多线程：每个线程在“同时”运行，是因为cpu在做着快读的切换，以达到同时运行的效果

体现：程序主线程在执行，垃圾回收也在执行，这是多线程的体现

1.Thread（继承类）

字段摘要static intMAX_PRIORITY 
          线程可以具有的最高优先级。10static intMIN_PRIORITY 
          线程可以具有的最低优先级。5static intNORM_PRIORITY 
          分配给线程的默认优先级。1 构造方法摘要Thread() 
          分配新的 Thread 对象。Thread(Runnable target) 
          分配新的 Thread 对象。Thread(Runnable target, String name) 
          分配新的 Thread 对象。Thread(String name) 
          分配新的 Thread 对象。

 方法摘要static ThreadcurrentThread() 
          返回对当前正在执行的线程对象的引用。 longgetId() 
          返回该线程的标识符。 StringgetName() 
          返回该线程的名称。 intgetPriority() 
          返回线程的优先级。 Thread.StategetStat() 
          返回该线程的状态。 voidsetName(String name) 
          改变线程名称，使之与参数 name 相同。 voidinterrupt() 
          中断线程。对线程冻结状态进行清除，强制让线程恢复到状态中来，可以操作标记让线程结束 voidsetDaemon(boolean on) 
          将该线程标记为守护线程或用户线程。当前台线程都结束后，守护线程自动结束（后台线程） voidjoin() 
          等待该线程终止。获得主线程执行权，等待该线程终止，主线程才执行。只有main方法叫主线程。 throws InterruptedException StringtoString() 
          返回该线程的字符串表示形式，包括线程名称、优先级和线程组。 voidsetPriority(int newPriority) 
          更改线程的优先级。所有线程优先级默认为5static voidyield() 
          暂停当前正在执行的线程。临时释放线程的执行权

1.1 要点：

（1）步骤：Thread子类需要重写run()方法，运行run()方法可通过start()方法。此时Java进程下就有两个线程了，主线程和我们创建的线程

（2）run方法：其就是一个存储器，存储线程要运行的代码

（3）start方法：开启新线程并运行。不用start()方法运行run()方法，程序还是单线程

（4）分析：运行结果每一次都不一样，因为多个线程都在争抢cpu执行权，不过每一时刻只能有一个线程在执行（多核除外）

/***需求：站台售票实例，通过继承实现多线程*思路：因为要多个对象共享票的数量，需要对票数进行静态修饰*/class ticket extends Thread{private static int tic = 100;//票数public ticket(String stageName){//站台名super(stageName);}public void run(){//线程的方法体while(true)if(tic>0)System.out.println(Thread.currentThread().getName()+"....还剩"+tic--+"张票");//System.out.println("票已经售完");}}class java{public static void main(String[] args){new ticket("站台1").start();new ticket("站台2").start();new ticket("站台3").start();new ticket("站台4").start();}}

1.2 线程运行的状态

（1）被创建：待运行

（2）运行：拥有运行资格以及执行权

（3）冻结：放弃了运行资格

（4）阻塞：拥有运行资格却没有执行权

（5）消亡：没有运行资格

2.Runnable（实现接口）

方法摘要 voidrun() 
          使用实现接口 Runnable 的对象创建一个线程时，启动该线程将导致在独立执行的线程中调用对象的 run 方法。

2.1 步骤

class MyThread implements Runnable{public void run(){//多线程要执行的方法体;System.out.println(Thread.currentThread().getName());}}class java{public static void main(String[] args){//建立自定义线程类对象Runnable r = new MyThread();//建立线程类，并通过Thread(Runnable r)来传入自定义线程类对象Thread t1 = new Thread(r);Thread t2 = new Thread(r);//运行多线程t1.start();t2.start();//简易写法new Thread(r).start();

2.2 特点

（1）好处：Java只支持单继承，如果该类已经是一个体系中子类，那么不能够运用继承来实现该类方法的多线程形式

（2）现状：实现方式最常用

3. 线程的安全

3.1 问题产生原因

（1）重要：当多条语句在操作同一个线程的共享数据时，一个线程对多条语句只执行了一部分，还没有执行完，另一个线程参与进来执行，导致共享数据的错误

3.2 问题的解决（synchronized——同步）

（1）同步代码格式如下

//同步代码块格式synchronized(对象){//对象为任意对象需要被同步的代码块}//同步函数格式synchronized 作为函数的修饰符

（2）同步的含义：同步就是确保同一时间段内只有一个线程能访问这段代码

（3）同步的前提

     <1>.必须要有一个或两个以上的线程

     <2>.必须是多个线程共同使用一把锁、监视器（锁就是对象，每一把锁都有自己的状态值，每进去一个线程此状态值都会变化）

（4）注意：同步较为消耗资源，所以尽可能减少判断的同步的次数，同步尽可能少的代码

（5）同步函数的要点

     <1>.同步函数使用的锁是 this

     <2>.静态同步函数使用的锁是 类名.class（字节码文件对象）

（6）死锁：同步嵌套同步，而且必须互相调用时，可能会发生。代码如下：

//死锁实现//死锁类，自定义线程类class DeadLock implements Runnable{private boolean flag;//标记DeadLock(boolean flag){this.flag = flag;}public void run(){if(flag)synchronized(MyLock.locka){//死锁嵌套形式System.out.println(Thread.currentThread().getName()+"......locka");synchronized(MyLock.lockb){System.out.println(Thread.currentThread().getName()+"......lockb");}}elsesynchronized(MyLock.lockb){System.out.println(Thread.currentThread().getName()+"......lockb");synchronized(MyLock.locka){System.out.println(Thread.currentThread().getName()+"......locka");}}}}//提供锁的类class MyLock{public static Object locka = new Object();public static Object lockb = new Object();}class java{public static void main(String[] args){new Thread(new DeadLock(true)).start();//多线程的简便写法，会创建两个定义一线程类对象new Thread(new DeadLock(false)).start();}}

4.线程间通信

4.1 情况阐述：

（1）多个线程中每个线程运行的代码都不同

4.2 等待唤醒机制

（1）方法摘要（Object类）

方法摘要 voidwait() 
          在其他线程调用此对象的 notify() 方法或 notifyAll() 方法前，导致当前线程等待。throws InterruptedException voidnotify() 
          唤醒在此对象监视器上等待的单个线程。 voidnotifyAll() 
          唤醒在此对象监视器上等待的所有线程。 voidwait(long timeout) 
          在其他线程调用此对象的 notify() 方法或 notifyAll() 方法，或者超过指定的时间量前，导致当前线程等待。throws InterruptedException（2）特点

      <1>.操作这些方法的对象是同步中的锁对象，因为可以通过监视器来确定线程。只有在同步中才能使用这些方法

      <2>.等待和唤醒必须是同一把锁，只有同一把锁的等待线程能被同一把锁的notify唤醒

      <3>.因为锁可以是任意对象，所以这些方法定义在Object类中

（3）输入和输出的代码体现（繁琐代码）————wait()、notify()的应用

/***需求：等待唤醒机制通过输入输出的形式体现。只适合两个线程，一个输入一个输出*思路：1.建立资源类，输入类，输出类*  2.输入类、输出类是多线程的实现类，并且分别用一个线程来控制其输入输出过程*  3.同步解决线程完全问题、等待唤醒机制实现输入一次输出一次的形式*/class Res{String name;String sex;boolean b = false;//等待唤醒的判断依据}class Input implements Runnable{//资源类的引用Res r;//保证传入对象唯一Input(Res r){this.r = r;}public void run(){int x = 0;//自定义的判断条件while(true){synchronized(r){if(r.b)try{r.wait();}catch(Exception e){}//等待机制if(x==0){r.name="张欣";r.sex="女";//输入}else{r.name="Tom";r.sex="man";}x = (x+1)%2;//通过此运算x的值始终为0或1r.notify();//唤醒机制r.b = true;}}}}class Output implements Runnable{//同上Res r;Output(Res r){this.r = r;}public void run(){while(true){synchronized(r){if(!r.b)try{r.wait();}catch(Exception e){}//等待机制System.out.println(r.name+"......"+r.sex);//输出r.notify();r.b = false;}}}}class java{public static void main(String[] args){Res r = new Res();//建立唯一的资源类对象new Thread(new Input(r)).start();new Thread(new Output(r)).start();//运行多线程}}

（4）生产者和消费者的代码体现（简化代码）————while多次判断标记、nitifyAll()唤醒全部等待线程

/***需求：用生产者消费者的形式来实现线程通信（有超过两个线程操作程序）*思路；1.建立资源类、生产者类、消费者类*  2.资源类中建立生产消费的函数，来被生产者消费者调用*  3.用同步解决线程安全问题，用等待唤醒全部机制保证生产一个消费一个*/class Resource{private String name;//商品名称private int count;//商品序号private boolean flag = false;//判断等待唤醒的标记Resource(String name){this.name = name;}//生产函数public synchronized void pdt(){while(flag)//多次判断标记try{wait();}catch(Exception e){} System.out.println(Thread.currentThread().getName()+"...生产者..."+(++count)+"."+name);//生产一个商品，每生产一个序号+1flag = true;notifyAll();//唤醒全部等待线程}//销售函数public synchronized void sell(){while(!flag)try{wait();}catch(Exception e){}System.out.println(Thread.currentThread().getName()+"...消费者........."+count+"."+name);//销售一个商品flag = false;notifyAll();}}class Produce implements Runnable{private Resource res;//资源引用Produce(Resource res){//保证资源对象唯一this.res = res;}//多线程run方法，存放生产的过程public void run(){while(true){res.pdt();}}}class Customer implements Runnable{private Resource res;//资源引用Customer(Resource res){//保证对象唯一this.res = res;}//多线程run方法，存放销售的过程public void run(){while(true){res.sell();}}}class java{public static void main(String[] args){//建立要用的唯一资源对象Resource res = new Resource("手办");//建立两个生产线程new Thread(new Produce(res)).start();new Thread(new Produce(res)).start();//建立两个销售线程new Thread(new Customer(res)).start();new Thread(new Customer(res)).start();}}类 ReentrantLock

5. JDK5.0升级

5.1 知识

（1）JDK5.0升级后多线程的同步与等待唤醒机制被替代，工具包位置为 java.util.concurrent.locks

（2）synchronized关键字的功能被lock接口子类ReentrantLock中的方法替代，wait()、nitify()、notifyAll()被Condition接口子类 中的方法所替代

5.2 类概要

Lock接口（常用子类——ReentrantLock）

方法摘要 voidlock() 
          获取锁。 voidunlock() 
          释放锁。ConditionnewCondition() 
          返回绑定到此 Lock 实例的新 Condition 实例。

Condition接口

方法摘要 voidawait() 
          造成当前线程在接到信号或被中断之前一直处于等待状态。throws InterruptedException voidsignal() 
          唤醒一个等待线程。 voidsignalAll() 
          唤醒所有等待线程。

5.3 实现代码（实现本方只唤醒对方的操作，上边生产者消费者代码的转型）

/***需求：用JDK5.0新特性实现生产者和消费者线程通信*思路；1.建立资源类、生产者类、消费者类*  2.资源类中建立生产消费的函数，来被生产者消费者调用*  3.用同步解决线程安全问题，用等待唤醒全部机制保证生产一个消费一个*/import java.util.concurrent.locks.*;class Resource{private String name;//商品名称private int count;//商品序号private boolean flag = false;//判断等待唤醒的标记private Lock lock = new ReentrantLock();//同步对象private Condition conditionPro = lock.newCondition();//锁对象private Condition conditionCus = lock.newCondition();Resource(String name){this.name = name;}//生产函数public void pdt(){lock.lock();//锁住try{while(flag)//多次判断标记conditionPro.await();System.out.println(Thread.currentThread().getName()+"...生产者..."+(++count)+"."+name);//生产一个商品，每生产一个序号+1flag = true;conditionCus.signalAll();//指定唤醒哪些线程}catch(Exception e){}finally{lock.unlock();//释放锁}}//销售函数public void sell(){lock.lock();try{while(!flag)conditionCus.await();System.out.println(Thread.currentThread().getName()+"...消费者........."+count+"."+name);//销售一个商品flag = false;conditionPro.signalAll();}catch(Exception e){}finally{lock.unlock();//释放锁}}}class Produce implements Runnable{private Resource res;//资源引用Produce(Resource res){//保证资源对象唯一this.res = res;}//多线程run方法，存放生产的过程public void run(){while(true){res.pdt();}}}class Customer implements Runnable{private Resource res;//资源引用Customer(Resource res){//保证对象唯一this.res = res;}//多线程run方法，存放销售的过程public void run(){while(true){res.sell();}}}class java{public static void main(String[] args){//建立要用的唯一资源对象Resource res = new Resource("手办");//建立两个生产线程new Thread(new Produce(res)).start();new Thread(new Produce(res)).start();//建立两个销售线程new Thread(new Customer(res)).start();new Thread(new Customer(res)).start();}}

知识点：当多个不操作共享数据的程序运行时，分别定义多线程效率较高，可以使用匿名内部类的方式