Java多线程操作

基本概念
进程：每个独立运行的程序称为进程，即“一个正在运行的程序”
线程：一个进程可包含多个线程，线程即程序内部的一条执行路径。


Java中创建线程的两种方法：
1. 继承Thread类
2. 实现Runable接口


（1）通过Thread类来创建线程
java.lang.Thread类(一个Thread类的对象代表一个线程)
一个代码被执行，一定是在某个线程上运行的，代码与线程密不可分，同一段代码可以与多个线程相关联，在多个线程上执行的可以使相同的一段代码。

方法说明：
static Thread currentThread()返回对当前正在执行的线程对象的引用。

String getName()返回该线程的名称。

class TestThread{public void run(){while(true){System.out.println(Thread.currentThread().getName()+" is running");}}}public class ThreadDemo1 {public static void main(String[] args) {/** * public void run()如果该线程是使用独立的 Runnable 运行对象构造的 * 则调用该 Runnable 对象的 run 方法；否则，该方法不执行任何操作并返回。  */new TestThread().run();while(true){System.out.println("main thread is running");}}}

上面的代码运行后，屏幕不停的打印 main is running，而不是 main thread is running 。对代码修改如下：

class TestThread2 extends Thread{public void run(){while(true){System.out.println(Thread.currentThread().getName()+" is running");}}}public class ThreadDemo2 {public static void main(String[] args) {/** * public void start()使该线程开始执行； * Java 虚拟机调用该线程的 run 方法。  */new TestThread2().start();//run();while(true){System.out.println("main thread is running");}}}

这里，TestThread2继承了Thread类，程序调用了该类对象的start方法。运行显示，看到两个while循环交替运行。

Java单线程与多线程的比较：
1. 可见，在单线程中，main函数必须等到TestThread.run()函数返回后才能继续往下执行。
而在多线程中，main函数调用TestThread.start()方法启动了TestThread.run()函数后，main函数不等待TestThread.run函数返回就继续运行。

2. 要将一段代码在一个新的线程上运行，该代码应该在一个类的run函数中，并且run函数所在类是Thread类的子类。在子类的run函数中高调用想在新线程上运行的程序代码。

3. 启动一个新的线程，不是直接调用Thread子类对象的run方法，而是直接调用Thread子类对象的start(从Thread类中继承的)方法，Thread类对象的start方法将产生一个新的线程，并在该线程上运行该Thread类对象中的run方法。

（2）使用Runnable接口创建多线程 / 实现 Runnable 接口

构造器 public Thread(Runnable target)

Runnable接口：其只有一个run()方法。当使用上述构造器创建线程对象时，行为该方法传递一个实现
Runnable接口的类对象，这样创建的线程将调用那个实现了Runnable接口的类对象中的run()方法作为其运行代码。

public class ThreadDemo3 {public static void main(String[] args) {/* * Thread(Runnable target) * 需要传递一个实现了Runnable接口的类对象 * Runnable接口中只定义了run()方法 */TestThread3 tt3 = new TestThread3();Thread t = new Thread(tt3);t.start();while(true){System.out.println("main thread is running");}}}class TestThread3 implements Runnable{/* * 线程的代码段，当执行start时，线程从此开始执行 */public void run(){while(true){System.out.println(Thread.currentThread().getName()+" is running");}}}

例子：有4个售票亭准备出售某场比赛的100张票，使用多线程方式实现。

提示：多个线程去处理一个资源，一个资源只能对应一个对象 ---> 使用Runnable接口方式

public class TicketTest {public static void main(String[] args) {TicketThread tt = new TicketThread();new Thread(tt).start();new Thread(tt).start();new Thread(tt).start();new Thread(tt).start();}}class TicketThread implements Runnable{private int tickets=100;@Overridepublic void run() {for(int i=0;i<1000;i++){if(tickets>0){System.out.println(Thread.currentThread().getName()+" selles No." + tickets--);}}}}

在上面的程序中，创建了是个线程，每个线程调用的是同一个TicketThread对象中的run方法，访问的是同一个对象中的变量(tickets)的实例，这个程序满足了我们的要求。

可见，实现Runnable接口相对于继承Thread类来说，有如下好处：

1） 适合多个相同程序代码的线程去处理同一资源的情况，数据与代码分离
2） 避免Java单继承带来的局限。
3） 有利于程序的健壮性，代码能够被多个线程共享，代码与数据是独立的

多线程的同步

（1）线程的安全性问题：
即使是上面的实现方式中仍然是有安全隐患的，在run方法中故意增加延迟（调用sleep方法），便会显现。

Thread类有如下方法：
public static void sleep(long millis)
在指定的毫秒数内让当前正在执行的线程休眠（暂停执行）

e.g 在上面的卖票例子的示例程序修改如下，便会出现线程同步问题：

public void run() {for(int i=0;i<1000;i++){if(tickets>0){Thread.sleep(10);System.out.println(Thread.currentThread().getName()+" selles No." + tickets--);}}}

说明：线程的睡眠是可以被打断的，通过Thread.interrupt(),线程的睡眠被打断进入Runnable状态。

所谓“你写的类是线程安全的吗？”就是说你编写的那个类的同一个实例对象的方法在多个线程被调用，是否会出现类似上面的意外。

--->为解决上面的问题，就要考虑到 线程同步 的问题！


（2）同步代码块
在同一时刻，只能有一个线程可以进入同步代码块运行。

格式为：
synchronized(this) 
{
//需要同步的语句块
}


输出结果显示，修改后的程序是线程安全的。
--->关于这方面详细、通俗、专业的解释见 PDF p208

为什么用 this ? ---- 代码块与函数间的同步
不管我们编写的类的内部结构如何，类中的非静态方法始终都能访问到的一个对象就是这个对象本身，即 this 。
线程同步靠的是检查同一对象的标志位，只要让代码块与函数使用同一个监视器对象。

（3）同步方法/同步函数
可以对需要同步的方法定义前加上 synchronized 关键字。其后该方法调用只能够互斥的进行。

修改上述程序：

class TicketThread implements Runnable {private int tickets = 100;@Overridepublic void run() {sale();}synchronized void sale() {for (int i = 0; i < 1000; i++) {if (tickets > 0) {try {Thread.sleep(10);} catch (InterruptedException e) {e.printStackTrace();}System.out.println(Thread.currentThread().getName()+ " selles No." + tickets--);}}}}

补充：JAVA 1.5 开始出现了同步锁功能
通过显示定义同步锁对象来实现同步，这种机制，同步锁应该使用Lock对象充当。

在实现线程安全控制中，通常使用ReentrantLock(可重入锁)。使用该对象可以显示地加锁和解锁。

具有与使用 synchronized 方法和语句所访问的隐式监视器锁相同的一些基本行为和语义，但功能更强大。

格式：

public class X {private final ReentrantLock lock = new ReentrantLock();//定义需要保证线程安全的方法public void  m(){//加锁lock.lock();try{//... method body}finally{//在finally释放锁lock.unlock();}}}

对上述程序进行修改：

class TicketTest5 implements Runnable{private final ReentrantLock lock = new ReentrantLock();private int tickets = 100;@Overridepublic void run() {for(int i=0;i<1000;i++){sale();}}public void sale(){lock.lock();if(tickets>0){try {Thread.sleep(1);System.out.println(Thread.currentThread().getName()+"卖出了第"+tickets-- +"张票");}catch(Exception e){e.printStackTrace();}finally{lock.unlock();}}}}

（4）代码块与函数间的同步
--如何实现？线程同步靠的是检查同一对象的标志位，只要让代码块与函数使用同一个监视器对象，答案就应该是肯定的！

那么函数中用的监视器对象是哪个呢？----->不管我们编写的类的内部结构怎样，类中的非静态方法始终都能访问到一个对象就是这个对象本身，即 this ，看来，同步函数所用的监视器对象只能是 this 。