范例解说Java里的线程概念与线程同步技术 - JAVA专栏

本文以通俗易懂的范例入手，由浅入深的全面介绍了Java里的线程概念与线程同步技术。

Page:  <1|2>

线程 是一段完成某个特定功能的代码，程序中的执行线程。Java 虚拟机允许应用程序并发地运行多个执行线程。
每个线程都有一个优先级，高优先级线程的执行优先于低优先级线程。
进程不同的是，由同名类生成的多个线程共享相同的内存空间和系统资源。

线程与进程的区别：
一个线程是一个程序内部的顺序控制流。
1. 进程：每个进程都有独立的代码和数据空间（进程上下文） ，进程切换的开销大。线程：同一类线程共享代码和数据空间，每个线程有独立的运行栈和程序计数器（PC），线程切换的开销小。
2. 一个进程中可以包含多个线程。

本文将介绍以下线程方面的知识：
1，线程的创建
2，线程的状态
3，线程同步
4，线程组

理解线程的最有效的方法是通过实例来理解。下面我们将通过 售货员售书 为例，由浅入深地介绍线程的创建，通信，锁机制等概念。

售货员售书
我们 假设一下售货员售书的操作流程：
1，我们假设有20本书，交给2个售货员去卖。
2，售货员可以卖掉任何一本尚未卖出去的书。换句话说，同 一本书若被其中一位售出去了，则不能被另外一位再售出了。

清单1：

文件名	说明
Book.java	书籍类
SellBookRunnable.java	售书类，线程的创建方法之一，该类实现了Runnable 接口，并实现了 run 方法。
SellBookThread.java	售书类，线程的创建方法之一，该类声明为 Thread 的子类，并重写 Thread 类的 run 方法。
CallSellBook.java	调用类。该类分别介绍了2种不同线程创建的调用方法。

Book.java

public class Book {
    private String name;
    private boolean sold = false;

    public Book(String name) {
        this.name = name;
    }
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public boolean isSold() {
        return sold;
    }

    public void setSold(boolean sold) {
        this.sold = sold;
    }
}

SellBookRunnable.java

import java.util.List;

public class SellBookRunnable implements Runnable {
    private String saleMan;
    private List<Book> bookList;

    public SellBookRunnable(String saleMan, List<Book> bookList) {
        this.saleMan = saleMan;
        this.bookList = bookList;
    }

    public void run() {
        for (int i = 0; i < bookList.size(); i++) {
            Book book = bookList.get(i);
            sellBook(book);
        }
    }

    /**
     * 售货员卖书。我们这样描述售货员的卖书过程。
     *
     * @param book Book
     */
    private void sellBook(Book book) {
        //从开始售书-到售书完成，使用
    synchronized (book)保证book不被其他售货员售出
        synchronized (book) {
            if (book.isSold()) {
                return;
            } else {
                try {
                    //为了让各线程有执行
    机会，设置平均售书时间为0.5秒
                    Thread.sleep(500);
                } catch (Exception e) {
                }

                //设置已售标志
                book.setSold(true);
                //打印该书已售信息
                System.out.println("[" + saleMan + "]" + book.getName() + " sold out:"
                        + book.isSold() + ". by "
                        + Thread.currentThread().getName());

            }
        }
    }
}

SellBookThread.java

import java.util.List;

public class SellBookThread extends Thread {
    private String saleMan;
    private List<Book> bookList;

    public SellBookThread(String saleMan, List<Book> bookList) {
        this.saleMan = saleMan;
        this.bookList = bookList;
    }

    public void run() {
        for (int i = 0; i < bookList.size(); i++) {
            Book book = bookList.get(i);
            sellBook(book);
        }
    }

    /**
     * 售货员卖书。我们这样描述售货员的卖书过程。
     *
     * @param book Book
     */
    private void sellBook(Book book) {
        //从开始售书-到售书完成，使用
    synchronized (book)保证book不被其他售货员售出
        synchronized (book) {
            if (book.isSold()) {
                return;
            } else {
                try {
                    //为了让各线程有执行
    机会，设置平均售书时间为0.5秒
                    Thread.sleep(500);
                } catch (Exception e) {
                }

                //设置已售标志
                book.setSold(true);
                //打印该书已售信息
                System.out.println("[" + saleMan + "]" + book.getName() + " sold out:"
                        + book.isSold() + ". by "
                        + Thread.currentThread().getName());

            }
        }
    }
}

CallSellBook.java

import java.util.ArrayList;
import java.util.List;

//该类调用SellBookXxx类
public class CallSellBook {

    /**
     * 用线程模拟这个售书的过程
     */
    public static void main(String[] args) {
        //方法1：
        callSellBookThread();

        //or

        //方法2：
        //callSellBookRunnable();
    }

    //调用SellBookRunnable（Runnable接
    口实现类）模拟售书过程
    public static void callSellBookThread() {
        List <Book>bookList = getBookListForSale();

        //将预售书籍清单交给售货员SaleMan1
        Thread t1 = new SellBookThread("SaleMan1", bookList);
        //将预售书籍清单交给售货员SaleMan2
        Thread t2 = new SellBookThread("SaleMan2", bookList);

        //售货员SaleMan1开始售书
        t1.start();
        //售货员SaleMan2开始售书
        t2.start();
    }


    //调用SellBookRunnable（Runnable接
    口实现类）模拟售书过程
    public static void callSellBookRunnable() {
        List <Book>bookList = getBookListForSale();

        //将预售书籍清单交给售货员SaleMan1
        Thread t1 = new Thread(new SellBookRunnable("SaleMan1", bookList));
        //将预售书籍清单交给售货员SaleMan2
        Thread t2 = new Thread(new SellBookRunnable("SaleMan2", bookList));

        //售货员SaleMan1开始售书
        t1.start();
        //售货员SaleMan2开始售书
        t2.start();
    }

    //准备预售书籍
    public static List<Book> getBookListForSale() {
        List <Book>bookList = new ArrayList();
        for (int i = 0; i < 20; i++) {
            Book book = new Book("Book" + i);
            bookList.add(book);
        }

        return bookList;
    }
}

执行CallSellBook

[SaleMan1]Book0 sold out:true. by Thread-0
[SaleMan2]Book1 sold out:true. by Thread-1
[SaleMan2]Book2 sold out:true. by Thread-1
[SaleMan2]Book3 sold out:true. by Thread-1
[SaleMan2]Book4 sold out:true. by Thread-1
[SaleMan2]Book5 sold out:true. by Thread-1
[SaleMan1]Book6 sold out:true. by Thread-0
[SaleMan1]Book7 sold out:true. by Thread-0
[SaleMan1]Book8 sold out:true. by Thread-0
[SaleMan1]Book9 sold out:true. by Thread-0
[SaleMan1]Book10 sold out:true. by Thread-0
[SaleMan1]Book11 sold out:true. by Thread-0
[SaleMan2]Book12 sold out:true. by Thread-1
[SaleMan2]Book13 sold out:true. by Thread-1
[SaleMan2]Book14 sold out:true. by Thread-1
[SaleMan2]Book15 sold out:true. by Thread-1
[SaleMan2]Book16 sold out:true. by Thread-1
[SaleMan2]Book17 sold out:true. by Thread-1
[SaleMan1]Book18 sold out:true. by Thread-0
[SaleMan1]Book19 sold out:true. by Thread-0

下一页：线程的创建方法，线程状态，线程同步等