多线程

多线程

进程和线程

程序与进程

程序：一段静态的代码。

进程：程序的一次动态执行过程，它对应从代码加载、执行到执行完毕的一个完整过程。

线程：是比进程更小的执行单位，它是在一个进程中独立的控制流，即程序内部的控制流。

特点：线程不能独立运行，必须依赖于进程，在进程中运行。

每个程序至少有一个线程称为主线程。

单线程：只有一条线程的进程称为单线程

多线程：有不止一个线程的进程称为多线程

 多线程优势

提高界面程序的相应速度。

充分利用系统资源

在实现线程编程时，首先需要让一个类具备多线程的能力，继承Thread类或实现Runnable接口的类具备多线程的能力；然后创建线程对象；调用对应的启动线程方法即可实现多线程编程。

在一个程序中可以实现多个线程，多线程编程指在同一个程序中启动了两个或两个以上的线程。

 在实际实现线程时，Java语言提供了两种实现方式：

继承Thread类

实现Runnable接口

    实现java.lang.Runnable接口并且在该类中重写Runnable接口的run方法。

   好处：在于多线程应用对象可以继承其它对象而不是必须继承Thread类，按照Java语言的语法，一个类可以实现任意多个接口，因此该种实现方式在实际实现时的通用性要比前面介绍的方式好一些。

1.实现java.lang.Runnable接口；

2.重写Runnable接口的run方法；

3.创建Runnable接口的子类对象；

4.创建Thread类的对象，并将Runnable接口的子类对象作为参数传递给Thread类的构造方法，最后调用Thread对象的start方法即可启动线程。

    Runnable1 r1 = new Runnable1();

    Thread t1 = new Thread(r1);

    t1.start();

 新建（new Thread）

    当创建Thread类的一个实例（对象）时，此线程进入新建状态（未被启动）。

    例如：Thread  t1=new Thread();

就绪（runnable）

      当调用start（）方法时，该线程进入就绪状态，线程已经被启动，正在等待被分配给CPU时间片，也就是说此时线程正在就绪队列中排队等候得到CPU资源。   

   例如：t1.start();

  运行（running）

   线程获得CPU资源正在执行任务（run()方法），此时除非此线程自动放弃CPU资源或者有优先级更高的线程进入，线程将一直运行到结束。

正在睡眠
用sleep(long t)方法可使线程进入睡眠方式。一个睡眠着的线程在指定的时间过去可进入就绪状态。

正在等待
调用wait()方法。（调用motify()方法回到就绪状态）

被另一个线程所阻塞
调用suspend()方法。（调用resume()方法恢复）

终止状态（dead）

     当线程执行完毕或被其它线程杀死，线程就进入死亡状态，这时线程不可能再进入就绪状态等待执行。

自然终止：正常运行run()方法后终止

异常终止：调用stop()方法让一个线程终止运行

可以用线程对象的isAlive()方法测试该线程是否已启动。

线程优先级

把线程从就绪状态进入运行状态的过程叫做线程调度。负责调度工作的机构叫做调度管理器。

优先级：线程的优先级的取值范围是1~10。
MAX_PRIORITY    =    10
NORM_PRIORITY   =   5
MIN_PRIORITY    =    1

得到或修改线程的优先级
public final int getPriority();
public final void setPriority(int newPriority);

线程睡眠sleep()

执行该方法使当前线程睡眠（停止执行）若干毫秒，线程由运行状态进入不可运行状态，睡眠时间过后线程再进入可运行状态。

例：电子时钟

packagecom.hbsi1;

importjavax.swing.*;

importjava.util.*;

public classTestClock {

 

         public static void main(String[] args){

                   JFrame jf=newJFrame("Clock");

                   JLabel clock=newJLabel("clock");

                   clock.setHorizontalAlignment(JLabel.CENTER);

                   jf.add(clock);

                   jf.setSize(140,80);

                   jf.setLocation(500,300);

                   jf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

                   jf.setVisible(true);

                   MyThread1 t=newMyThread1(clock);

                   t.start();

         }

}

classMyThread1  extends Thread{

         private JLabel clock;

         public MyThread1(JLabel clock){

                   this.clock=clock;

         }

         public void run(){

                   while(true){

                            clock.setText(getTime());

                            try {

                                     Thread.sleep(1000);

                            } catch(InterruptedException e) {

                                     // TODOAuto-generated catch block

                                     e.printStackTrace();

                            }

                   }

                  

         }

         public String getTime(){

                   //Calendarc=Calendar.getInstance();

                   Calendar c=newGregorianCalendar();

                   Stringtime=c.get(Calendar.YEAR)+"-"+(c.get(Calendar.MONTH)+1)+"-"+(c.get(Calendar.DATE))+"  ";

                   int h=c.get(Calendar.HOUR);

                   int m=c.get(Calendar.MINUTE);

                   int s=c.get(Calendar.SECOND);

                   Stringph=h<10?"0":"";

                   Stringpm=m<10?"0":"";

                   Stringps=s<10?"0":"";

                   time+=ph+h+":"+pm+m+":"+ps+s;

                   return time;

         }

}

2暂停线程yield()

  调用yield()方法暂停当前线程执行，将CPU资源让出来，允许其他线程执行。该线程仍处于可运行状态。不转变为阻塞状态。此时，系统选择其他同优先级线程执行，若无其他同优先级线程，则选中该线程继续执行。yield()方法的优点是：保证有工作时不会让CPU闲置。主要用于编写多个合作线程，也适用于强制线程间的合作。

例13.6 yield方法的使用示例。

 中断线程interrupt()

  public void interrupt()

  public boolean isInterrupted()

  public static boolean interrupted()

 

如果多个线程同时访问一个资源，例如变量、文件等，如何保证访问安全的问题。在多线程编程中，这种会被多个线程同时访问的资源叫做临界资源。

解决这个问题最基本，最简单的思路就是使用同步关键字synchronized。synchronized关键字是一个修饰符，可以修饰方法或代码块，其的作用就是，对于同一个对象（不是一个类的不同对象），当多个线程都同时调用该方法或代码块时，必须依次执行，也就是说，如果两个或两个以上的线程同时执行该段代码时，如果一个线程已经开始执行该段代码，则另外一个线程必须等待这个线程执行完这段代码才能开始执行。