java 线程

一、线程的基本概念

　　

线程理解：线程是一个程序里面不同的执行路径

　　每一个分支都叫做一个线程，main()叫做主分支，也叫主线程。

　　程只是一个静态的概念，机器上的一个.class文件，机器上的一个.exe文件，这个叫做一个 进程。程序的执行过程都是这样的：首先把程序的代码放到内存的代码区里面，代码放到代码区后并没有马上开始执行，但这时候说明了一个进程准备开始，进程已 经产生了，但还没有开始执行，这就是进程，所以进程其实是一个静态的概念，它本身就不能动。平常所说的进程的执行指的是进程里面主线程开始执行了，也就是main()方法开始执行了。进程是一个静态的概念，在我们机器里面实际上运行的都是线程。

　　Windows操作系统是支持多线程的，它可以同时执行很多个线程，也支持多进程，因此Windows操作系统是支持多线程多进程的操作系统。Linux和Uinux也是支持多线程和多进程的操作系统。DOS就不是支持多线程和多进程了，它只支持单进程，在同一个时间点只能有一个进程在执行，这就叫单线程。

　　CPU难道真的很神通广大，能够同时执行那么多程序吗？不是的，CPU的执行是这样的：CPU的速度很快，一秒钟可以算好几亿次，因此CPU把自己的时间分成一个个小时间片，我这个时间片执行你一会，下一个时间片执行他一会，再下一个时间片又执行其他人一会，虽然有几十个线程，但一样可以在很短的时间内把他们通通都执行一遍，但对我们人来说，CPU的执行速度太快了，因此看起来就像是在同时执行一样，但实际上在一个时间点上，CPU只有一个线程在运行。

学习线程首先要理清楚三个概念：

1. 进程：进程是一个静态的概念
2. 线程：一个进程里面有一个主线程叫main()方法，是一个程序里面的，一个进程里面不同的执行路径。
3. 在同一个时间点上，一个CPU只能支持一个线程在执行。因为CPU运行的速度很快，因此我们看起来的感觉就像是多线程一样。

　　什么才是真正的多线程？如果你的机器是双CPU，或者是双核，这确确实实是多线程。

二、线程的创建和启动

 

 

　　

 

　　在JAVA里面，JAVA的线程是通过java.lang.Thread类来实现的，每一个Thread对象代表一个新的线程。创建一个新线程出来有两种方法：第一个是从Thread类继承，另一个是实现接口runnable。VM启动时会有一个由主方法(public static void main())所定义的线程，这个线程叫主线程。可以通过创建Thread的实例来创建新的线程。你只要new一个Thread对象，一个新的线程也就出现了。每个线程都是通过某个特定的Thread对象所对应的方法run()来完成其操作的，方法run()称为线程体。

 

范例1：使用实现Runnable接口创建和启动新线程

 

开辟一个新的线程来调用run方法

 

/**
 * java  开辟新线程
 * 2016/5/7
 **/
package org.Thread;


public class TestThread {

    public static void main(String[] args) {
        Runner_1 r1 = new Runner_1();  //new一个线程类的对象出来
        //r1.run();  这个方法调用的执行是等run()方法执行完之后才会继续继续执行main()方法
        Thread t = new Thread(r1);  //要启动一个新的线程就必须ｎｅｗ一个Thread对象出来
        t.start();//启动新开辟的线程，新线程执行的是run()方法，新线程与主线程回忆起并行执行
        for(int i = 0; i < 10; i++){
            System.out.println("mainthead:"+ i);
        }
    }
}

class Runner_1 implements Runnable{
    Runner_1(){};
    public void run(){
        for(int i = 0; i < 10; i++){
            System.out.println("Runner_1:"+i);
        }
    }
}

 执行结果：

Runner_1:0
mainthead:0
mainthead:1
Runner_1:1
mainthead:2
Runner_1:2
mainthead:3
Runner_1:3
mainthead:4
Runner_1:4
mainthead:5
Runner_1:5
Runner_1:6
Runner_1:7
Runner_1:8
Runner_1:9
mainthead:6
mainthead:7
mainthead:8
mainthead:9

 三、创建线程池

Thread方法对于单一的任务的执行很方便，方式由于必须为每一个任务创建一个线程，所以对大量任务不够高效。所以提出线程池的概念。

/**
 * 线程池，如果要为多个任务创建线程，就需要使用线程池，而不是Thread
 * 2016/6/14
 */
package org.Thread;

import java.util.concurrent.*;

public class ExecutorDemo {
    
    public static void main(String[] args) {
        //创建3个固定的线程池
        ExecutorService executor = Executors.newFixedThreadPool(3);

        executor.execute( new Print_1());
        executor.execute(new Print_2());
        executor.execute(new Print_3());
        
        executor.shutdown();        //通知执行器关闭，不能接受新的任务，但是现有任务将继续执行直至完成
    }

}

class Print_1 implements Runnable{
    Print_1(){};
    public void run(){
        for(int i = 0; i < 20; i++)
        System.out.println("这是任务1×××××××××");
    }
}

class Print_2 implements Runnable{
    Print_2(){};
    public void run(){
        for(int i = 0; i < 20; i++)
        System.out.println("这是任务2########");
    }
}

class Print_3 implements Runnable{
    public void run(){
        for(int i = 0; i < 20; i++)
        System.out.println("这是任务3&&&&&&&&");
    }
}

 

执行结果部分截图：

四、多线程同步问题

如果一个资源被多个线程同时访问的话，就有可能会找到破坏。

/**
 * java 多线程同步问题
 * 2016/5/14
 **/
package org.Thread;

import java.util.concurrent.*;
public class ExecutorSynch {
    private static Account  account = new Account();

    public static void main(String[] args) {
        ExecutorService executor = Executors.newCachedThreadPool();

        for(int i = 0; i < 100; i++){
            executor.execute(new AddApennyTask());
        }

        executor.shutdown();

        while(!executor.isTerminated()){
            
        }

        System.out.println("what is balance?  " + account.getBalance());

    }

    private static class AddApennyTask implements Runnable{
        public void run(){
            account.deposit(1);
        }
    }
    private static class Account{
        private int balance = 0;
        public int getBalance(){
            return balance;
        }

        public void deposit(int amount){
            int newBalance = balance + amount;

            try{
                Thread.sleep(5);
            }catch(InterruptedException ex){
                
            }
            balance = newBalance;
        }
    }

}

 

 运行结果：

本来我们创建了100个线程，每个线程都向账户添加了1便士，100个线程结果按照预想的应该是100便士，但是结果确实不可预测的，这是因为第30、40、47行的代码在多个线程中被同时访问了

所以导致结果不可预测。

解决方法一：我们可以使deposit方法中添加关键字synchronized，使Account类成为线程安全的。

将39行换为：public synchronized void deposit (int amount)

 

解决方法二：利用同步语句块使得线程安全。

将第39行的语句放入到同步块中：

　　synchronized (account) {

　　　　account.deposit(1);

　　}

 

方法三：利用加锁来进行同步；

 

/**
 * java 线程池 利用加锁同步
 * 2016/5/15
 **/
package org.Thread;

import java.util.concurrent.*;
import java.util.concurrent.locks.*;

public class ExecutorSynchLock {

    private static Account  account = new Account();

    public static void main(String[] args) {
        ExecutorService executor = Executors.newCachedThreadPool();
        //新建100个线程
        for(int i = 0; i < 100; i++){
            executor.execute(new AddApennyTask());
        }
        executor.shutdown();
        while(!executor.isTerminated()){
        }

        System.out.println("what is balance?  " + account.getBalance());

    }

    private static class AddApennyTask implements Runnable{
        public void run(){
            account.deposit(1);
        }
    }
    private static class Account{
        private int balance = 0;
        private static Lock lock = new ReentrantLock();     //创建锁
        public int getBalance(){
            return balance;
        }

        public void deposit(int amount){
            lock.lock();        //加锁
            try{
                int newBalance = balance + amount;
                Thread.sleep(5);
                balance = newBalance;
            }catch(InterruptedException ex){
            }finally{
                lock.unlock();　　//解锁
            }
        }
    }

}

 方法四：利用信号量模拟加锁保证同步

/**
 * java  线程 信号量
 * 2016/6/20
 */
package cn.thread;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Semaphore;


public class Semaphore_ {
    private static Account account = new Account();
    public static void main(String[] args){
        ExecutorService executor = Executors.newCachedThreadPool();
        //创建启动100个线程
        for(int i = 0; i < 100; i++){
            executor.execute(new AddAPennyTask());
        }
        executor.shutdown();
        //等待所有的任务完成
        while(!executor.isTerminated()) {
        }
        
        System.out.println("What is balance?" + account.getBalance());
    }
    //添加一便士
    private static class AddAPennyTask implements Runnable {
        public void run() {
                account.deposit(1);
        }
    }
    //账户类
    private static class Account {
        //创建只有一个许可的信号量，表示同时只有一个线程能访问deposit()方法
        private static Semaphore semaphore = new Semaphore(1);
        private int balance = 0;
        public int getBalance() {
            return balance;
        }
        //添加synchronized可以防止多个任务同时访问这个函数
        public  void deposit(int amount) {
            try{
                semaphore.acquire();    //捕获许可
                int newBalance = balance + amount;
                balance = newBalance;
                Thread.sleep(5);
            }catch (InterruptedException ex){
                
            }finally{
                semaphore.release();    //释放许可
            }
        }
    }
}

 

 

五、线程间的协作

有时候可能需要一个线程在某一情况下通知另一个线程执行某个任务。

比如取款时如果账户余额小于取款金额是就应该等待，直到有新的存款进入之后，再进行取款操作。

/**
 * java  线程间协作
 * 2016/6/20
 */
package cn.thread;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class ThreadCooperation {
    private static Account account = new Account();
    public static void main(String[] args){
        ExecutorService executor = Executors.newFixedThreadPool(2);
        executor.execute(new DepositTask());
        executor.execute(new WithdrawTask());
        executor.shutdown();
        
        System.out.println("Thread 1\t\tThread 2\t账户余额");
    }
    //给账户存款
    public static class DepositTask implements Runnable{
        public void run() {
            try {
                while (true){
                    account.deposit((int)(Math.random() * 10) + 1);
                    Thread.sleep(1000);
                }
            }catch (InterruptedException ex){
                ex.printStackTrace();
            }
        }
    }
    //从账户中提款
    public static class WithdrawTask implements Runnable {
        public void run() {
            while(true){
                account.withdraw((int)(Math.random() * 10) +1);
            }
        }
    }
    
    private static class Account {
        private static Lock lock = new ReentrantLock();
        
        private static Condition newDeposit = lock.newCondition();
        private int balance = 0;
        public int getBalance(){
            return balance;
        }
        public void withdraw(int amount){
            lock.lock();
            try {
                while(balance < amount){
                    System.out.println("\t\t\t等待存款");
                    newDeposit.await();
                }
                balance -= amount;
                System.out.println("\t\t\t提款" + amount + "\t\t" + getBalance());
            } catch (Exception e) {
                e.printStackTrace();
            }finally{
                lock.unlock();
            }
        }
        public void deposit(int amount){
            lock.lock();
            try {
                balance += amount;
                System.out.println("存款" + amount + "\t\t\t\t\t" + getBalance());
                newDeposit.signalAll();
            } catch (Exception e) {
            }finally{
                lock.unlock();
            }
        }
    }
}

 经典实例：生产者/消费者

/**
 * java 线程实例  生产者/消费者问题
 * 2016/6/20
 */
package cn.thread;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class ConsumerProducer {
    private static Buffer buffer = new Buffer();
    public static void main(String[] args){
        ExecutorService executor = Executors.newFixedThreadPool(2);
        executor.execute(new ProducerTask());
        executor.execute(new ConsumerTask());
        executor.shutdown();
        
    }
    //生产者
    private static class ProducerTask implements Runnable{
        public void run(){
            try {
                int i =1;
                while(true){
                    System.out.println("生产者生产" + i);
                    buffer.write(i++);
                    Thread.sleep((int)(Math.random() * 10000));
                    
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
    //消费者
    private static class ConsumerTask implements Runnable{
        public void run(){
            try {
                while(true){
                        
                    System.out.println("\t\t\t消费者消费" + buffer.read());
                    Thread.sleep((int)(Math.random() * 10000));
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
    
    private static class Buffer{
        private static final int CAPACITY = 1;
        private java.util.LinkedList<Integer>queue = new java.util.LinkedList<Integer>();
        //创建锁
        private static Lock lock = new ReentrantLock();
        
        private static Condition notEmpty = lock.newCondition();
        private static Condition notFull = lock.newCondition();
        
        public void write(int value){
            lock.lock();
            try {
                while(queue.size() == CAPACITY) {
                    System.out.println("等待notFull信号");
                    notFull.await();
                }
                queue.offer(value);
                notEmpty.signal();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }finally{
                lock.unlock();
            }
        }
        
        public int read(){
            int value = 0;
            lock.lock();
            try {
                while(queue.isEmpty()){
                    System.out.println("\t\t等待 notEmpty信号");
                    notEmpty.await();
                }
                
                value = queue.remove();
                notFull.signal();
            } catch (InterruptedException e){
                e.printStackTrace();
            }finally{
                lock.unlock();
            }
            return value;
        }
    }
}

 使用java内置的阻塞队列来简化上边生产者消费者例子

（此程序中同步已经在ArrayBlockingQueue中实现，所以不需要再手动编码进行实现）

/**
 * java 多线程/阻塞队列
 * 2016/6/20
 */
package cn.thread;

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class ConsumerProducerUsingBlockingQueue {
    private static ArrayBlockingQueue<Integer> buffer = new ArrayBlockingQueue<Integer>(2); 
    
    public static void main(String[] args){
        ExecutorService executor = Executors.newFixedThreadPool(2);//java内置的阻塞队列
        executor.execute(new ProducerTask());
        executor.execute(new ConsumerTask());
        executor.shutdown();
    }
    
    private static class ProducerTask implements Runnable{
        public void run(){
            try {
                int i = 1;
                while(true){
                    System.out.println("Priducer writes" + i);
                    buffer.put(i++);    //在队尾插入一个元素，如果队列已满则等待
                    Thread.sleep((int)(Math.random() * 10000));
                    
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
    
    private static class ConsumerTask implements Runnable{
        public void run(){
            try {
                while(true){
                    System.out.println("\t\t\tConsumer reads"+ buffer.take());//返回并删除这个队列的头，如果队列为空则等待
                    Thread.sleep((int)(Math.random() * 10000));
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

 

六、 创建一个有返回值的线程

我们通过实现Callable接口，实现call方法并且使用ExecutorService.submit()方法调用它就可以实现一个有返回值的线程任务。

package thread;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class TestCallable {
    public static void main(String[] args) throws InterruptedException, ExecutionException {
        Integer n;
        ExecutorService executor = Executors.newFixedThreadPool(1);
        n = executor.submit(new MyCallable(10)).get();
        System.out.println(n);
        executor.shutdown();
    }
}

class MyCallable implements Callable<Integer>{
    int num;
    public MyCallable(int num) {
        this.num = num;
    }

    @Override
    public Integer call() throws Exception {
        num = num * num;
        System.out.println("num:" + num);
        return num;
    }
    
}