JAVA学习十七：多线程

 

Java学习——多线程

 

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

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

 

一个进程中可以有多个线程，但至少必须要有一个线程。

 

Java中的JVM启动的时候会有一个进程java.exe，该进程中至少有一个线程负责java程序的执行，而且这个线程运行的代码存在于main方法中，该线程称为“主线程”。

 

自定义多线程的定义方法：

 

创建线程的第一种方式：继承Thread类。

步骤：

1、定义类继承Thread类。

2、复写Thread类中的run方法，目地是将自定义代码存储在run方法中，让线程来运行自定义代码。

3、调用线程的start()方法，该方法有两个作用，第一个作用是启动线程，第二个作用是调用run方法，让多线程执行run中的代码。

 

注：在多线程状态下，每次打印主线程和次线程的输出语句顺序都不一样，这是因为多个线程都在抢夺CPU的执行权，CPU执行到某个线程，某个线程就执行。

在某一时刻，只能有一个程序在运行（多核心CPU除外）。CPU在做着快速的切换，以达到看上去是同时运行的效果。

 

Thread类用于描述线程，该类就定义了一个功能，用于存储线程要运行的代码，该存储功能就是run方法；也就是说run方法在Thread类中的作用是：“用于存储线程要运行的代码”。

 

 

线程的状态

 

 

sleep：方法需要指定睡眠时间，单位是毫秒。

wait：等待。

notify：唤醒等待的线程。

stop：暂停。

 

 

示例：创建多线程

 

//继承了Thread类

Class Demo extends Thread

{

       public void run()

{

       for (int x=0；x<60；x++)

       {

              System.out.println(“次线程”+x)；

}

}

}

 

Class ThreadDemo

{

       public static void main(String[] args)

       {

              //创建好一线程

              Demo d = new Demo()；

             

              //开启线程并执行该线程的run方法。

d.start()；

 

//为了区分次线程的运行，这里也打印由主线程运行的循环。

for (int x=0；x<60；x++)

       {

              System.out.println(“主线程”+x)；

}

}

}

 

 

 

 

创建线程的第二种方式：实现Runnable接口

 

步骤：

1、定义类实现Runnable接口。

2、覆盖Runnable接口中的run方法，将线程要运行的代码存放在该run方法中。

3、通过Thread类建立线程对象。

4、将Runnable接口的子类对象作为实际参数传递给Thread类的构造函数；自定义的run方法所属的对象是Runnable接口的子类对象，为了让线程去执行指定的对象的run方法，就必须明确该run方法所属的对象。

5、调用Thread类的start()方法开启线程，并调用Runnable接口子类的run方法。

 

实现Runnable接口的好处是避免了单继承的局限性；在定义线程时，建议使用实现方式。

 

//实现了Runnable接口

class Test implements Runnable    

{

       private String name;

       Test(String name)

       {

              this.name = name;

       }

       public void run()           //覆盖父类中的run方法。

       {

              for (int x=0; x<60; x++)

                     System.out.println(name+"run"+x);

       }

}

 

class ThreadDemo4

{

       public static void main(String[] args)

       {

              new Thread(new Test("线程1")).start();//创建1线程，并运行1线程。

              new Thread(new Test("线程2")).start();//创建2线程，并运行2线程。

 

              for (int x=0; x<60; x++)

                     System.out.println("main "+x);

 

 

 

多线程的安全问题：

Java对于多线程的安全问题提供了专业的解决方式，使用同步代码块，可以有效的解决多线程的安全问题。

示例：synchronized（对象）｛需要被同步的代码；｝

这里的对象就如同“锁”，持有锁的线程可以在同步中执行，没有持有锁的线程即使获取CPU的执行权，也进不去，因为没有锁，就等于没有登陆权。

 

 

JDK1.5版本中提供了多线程升级解决方案。

该方案将原有的同步synchronized替换成了实现Lock的操作。

将Object中的wait，notify，notifyAll替换成了condition对象。

 

Lock的使用方法：

class BoundedBuffer

{

   Lock lock = new ReentrantLock();

   Condition notFull  = lock.newCondition();

   Condition notEmpty = lock.newCondition();

 

   final Object[] items = new Object[100];

   int putptr, takeptr, count;

 

   public void put(Object x) throws InterruptedException

{

     lock.lock();   //拿锁，获取锁

     try

       {

       while (count == items.length)

         notFull.await();    //notFull等待；

       items[putptr] = x;

       if (++putptr == items.length) putptr = 0;

       ++count;

       notEmpty.signal();   //唤醒notEmpty

     }

finally    

{     // finally是必须执行的，所以把释放锁的动作放在finally中。

       lock.unlock();   //释放锁，

     }

   }

 

   public Object take() throws InterruptedException

{

     lock.lock();   //拿锁

     try

{

       while (count == 0)

         notEmpty.await(); //notEmpty等待；

       Object x = items[takeptr];

       if (++takeptr == items.length) takeptr = 0;

       --count;

       notFull.signal();       //唤醒notFull；

       return x;

     }

finally

{

       lock.unlock();   //释放锁，放在finally中一定会执行到。

     }

   }

 }

 

 

注：在使用lock锁的过程中，因为要try一下await()，但是又不使用catch()进行处理，所以在函数上必须进行申明一个InterruptedException的异常。