多线程的神秘面纱...还在恐惧吗？？？

时间：2015-01-21 18:15:52 阅读：281 评论：0 收藏：0 [点我收藏+]

标签：java

前言

最开始学习java时，头都大了，也没学好多线程，甚至都不明白啥是多线程...慢慢的不断学习，发现多线程其实并没有我们想象中的困难。

进程（Processes）与线程（Threads）

在操作系统里面，存在着非常多的进程与线程。在每个单核处理器中，某个时刻仅有一个线程在执行。但是为什么我们在平时使用中，却感觉是有多个线程在运行呢？因为处理器使用了时间分片技术。也就是将处理器的执行时间分割成很多片段，然后将每个时间片段分配给不一样的线程，由于处理器的运行速度非常快，所以就给我们造成一种假象，处理器在同时执行多个线程。随着科技的发展，现在出现了多核处理器电脑，并且每个核心可超线程执行任务，由于每个核都是独立的，大大提高了电脑的并发执行能力。

进程（Processes）

进程通常拥有自己的执行环境，特别的，还拥有私有的内存空间。在某种程度上看，进程可以看做是一个程序或者是应用，比如我们使用win7/win8的任务管理器，可查看到系统的进程列表。为了让多个进程之间能够正常通讯，现代的操作系统一般使用Inter Process Communication（IPC）技术，也称之为进程间通讯。通畅使用管道（Pipes）、Socket等。在java里面，一般一个jvm代表了一个进程。

线程（Threads）

线程有时候也叫做轻量级的进程。在一个进程中，包含了一个或者多个线程，这些线程共享进程的执行环境，资源，内存。所以创建线程以及销毁线程的代价却比创建进程小的多。

创建线程

方式1：实现Runnable接口

public class HelloRunnable implements Runnable {
    public void run() {
        System.out.println("Hello from a thread!");
    }
    public static void main(String args[]) {
        (new Thread(new HelloRunnable())).start();
    }
}

方式二：继承Thread类

public class HelloThread extends Thread {
    public void run() {
        System.out.println("Hello from a thread!");
    }
    public static void main(String args[]) {
        (new HelloThread()).start();
    }
}

注意点：启动线程使用的是start方法，不是调用run()方法。
在这两种方式中，我们应该使用哪种呢？
推荐方式一，因为这样子代码看上去更加简洁，并且灵活性更高。比如一个类本身已经继承了别的Thread，那么就无法实现多次继承Thread。

暂停线程的执行（Pausing Execution）

为什么需要暂停线程的执行呢？大家可以回想下，在使用ServerSocket时，有个accept方法，这个方法是阻塞的，也就是会在等待客户端的socket连接。所以线程的暂停有着非常多的用处，比如等待别的任务执行，等待IO完成，等待网络等。那么如何停止一个线程呢？直接使用Thread.sleep(int time)

public class SleepMessages {
    public static void main(String args[])
        throws InterruptedException {
        String importantInfo[] = {
            "Mares eat oats",
            "Does eat oats",
            "Little lambs eat ivy",
            "A kid will eat ivy too"
        };


        for (int i = 0;
             i < importantInfo.length;
             i++) {
            //Pause for 4 seconds
            Thread.sleep(4000);
            //Print a message
            System.out.println(importantInfo[i]);
        }
    }
}

注意点，Thread.sleep()方法会抛出一个InterruptedException，这个异常的抛出，是由于中断了这个线程，那么这个线程就不能继续存活下去了。

线程的中断

在一个线程中，可以执行各种操作，假设某个操作非常耗时，或者进入了长时间的睡眠，这时候想要中断这个线程，那么可以使用Thread.interrupted()来中断线程。被中断的线程会直接被杀死。

for (int i = 0; i < inputs.length; i++) {
    heavyCrunch(inputs[i]);
    if (Thread.interrupted()) {
        throw new InterruptedException();
    }
}

线程的Join

在多个线程中，如果一个线程调用了join()，那么主线程就会被停止，直到调用了join()的那个线程执行完毕。

public class ThreadDemo{
	public static void main(String[] args){
	    Thread mainThread = Thread.currentThread();
		System.out.println(mainThread.getName() + " start");
		Thread joinThread = new Thread(new Runnable(){
		    @Override
			public void run(){
			    System.out.println("I am joinThread");
				try{
		            Thread.sleep(5000);
		        }catch(InterruptedException e){
		            e.printStackTrace();
		        }  
			}
		});    
		joinThread.start();
		try{
		    joinThread.join();
		}catch(InterruptedException e){
		    e.printStackTrace();
		}
		//this partition code has to wait the joinThread to complete
	    System.out.println("end");
	}
}

在这个例子中，最后主线程部分的System.out.println("end");部分的代码，需要一直等待joinThread的执行完成，这里为了简单，只有一句输出，其实可以为任何的代码。

下面这个简单的例子，有两个线程，一个是MessageLoop线程，不断的输出数据，另外一个是Main Thread。Main Thread由jvm直接创建，所以每个程序至少有一个线程，那就是主线程。MessageLoop t启动之后，就不断的输出数据，然后主线程就不断的询问该线程t是否存活，如果存活就让t暂停1秒钟，这里使用了t.join(1000)，然后判断程序的运行时间是否已经超过了patience标量，如果是，那就调用t.interrupt()方法来中断线程，最后主线程输出了Finally，表示结束。

public class SimpleThreads {


    // Display a message, preceded by
    // the name of the current thread
    static void threadMessage(String message) {
        String threadName =
            Thread.currentThread().getName();
        System.out.format("%s: %s%n",
                          threadName,
                          message);
    }


    private static class MessageLoop
        implements Runnable {
        public void run() {
            String importantInfo[] = {
                "Mares eat oats",
                "Does eat oats",
                "Little lambs eat ivy",
                "A kid will eat ivy too"
            };
            try {
                for (int i = 0;
                     i < importantInfo.length;
                     i++) {
                    // Pause for 4 seconds
                    Thread.sleep(4000);
                    // Print a message
                    threadMessage(importantInfo[i]);
                }
            } catch (InterruptedException e) {
                threadMessage("I wasn't done!");
            }
        }
    }


    public static void main(String args[])
        throws InterruptedException {


        // Delay, in milliseconds before
        // we interrupt MessageLoop
        // thread (default one hour).
        long patience = 1000 * 60 * 60;


        // If command line argument
        // present, gives patience
        // in seconds.
        if (args.length > 0) {
            try {
                patience = Long.parseLong(args[0]) * 1000;
            } catch (NumberFormatException e) {
                System.err.println("Argument must be an integer.");
                System.exit(1);
            }
        }


        threadMessage("Starting MessageLoop thread");
        long startTime = System.currentTimeMillis();
        Thread t = new Thread(new MessageLoop());
        t.start();


        threadMessage("Waiting for MessageLoop thread to finish");
        // loop until MessageLoop
        // thread exits
        while (t.isAlive()) {
            threadMessage("Still waiting...");
            // Wait maximum of 1 second
            // for MessageLoop thread
            // to finish.
            t.join(1000);
            if (((System.currentTimeMillis() - startTime) > patience)
                  && t.isAlive()) {
                threadMessage("Tired of waiting!");
                t.interrupt();
                // Shouldn't be long now
                // -- wait indefinitely
                t.join();
            }
        }
        threadMessage("Finally!");
    }
}

线程的同步

在线程中，由于资源、运行环境、内存等共享，所以会带来许多的问题，比如著名的死锁。下面的例子是一个简单的计数器

class Counter {
    private int c = 0;


    public void increment() {
        c++;
    }


    public void decrement() {
        c--;
    }


    public int value() {
        return c;
    }


}

如果这个类的对象只是被一个线程访问，那么每次increment()、decrement()，c就会+1或者-1。但是如果这个对象同时被多个线程持有，并且并发的访问，那么程序的预期，将和我们所想象的不一致。上面的程序，使用的是c++，c--语法，但是并不代表c++，c--的执行流程只有一个指令。实际上，c++分为下面三个步骤。
1、获得当前c的值
2、当前的值+1
3、将第2步的值保存起来

下面我们假设Thread A,B同时访问increment()，那么很可能发生如下的过程：

1、Thread A获得c的值，c=0
2、Thread B获得c的值，c=0,
3、Thread A将值+1，c=1
4、Thread B将值-1，c=-1
5、Thread A将值保存起来，c=1
6、Thread B将值保存起来，c=-1
假设c执行之前为0，那么之后的结果会是多少呢？没错，是-1。这和我们预期的结果0并不一致。
那么是什么造成了这个问题呢？大家可以参考下其他文档，总体来说就是，多个线程对同一个变量的修改，对其他线程来说，可能是不可见的。比如Thread A对c的修改，Thread B是不可见的。

同步方法（Synchronized Methods）
在java中，提供了对同步方法的原语支持，关键字就是synchronized。如下例子：

public class SynchronizedCounter {
    private int c = 0;
    public synchronized void increment() {
        c++;
    }
    public synchronized void decrement() {
        c--;
    }
    public synchronized int value() {
        return c;
    }
}

在方法中加入了synchronized，那么系统就会保证如下的两个特性：
1、当一个线程访问一个synchronized方法时，其他方法只能等待。比如在上面例子中，Thread A假设在执行increment()，那么Thread B就必须等待Thread A的执行完毕。
2、一个线程执行完毕之后的结果，对于其他线程来说，结果是可见的。比如Thread A执行increment()之后，c的值为1，那么这时候Thread B获得的值也就是1。

内部锁（Intrinsic Locks）

锁，就是用来保护某一段代码只能被一个Thread访问。其他程序如果想要访问这段代码，就需要获得锁。使用synchronized methods，虚拟机会为整个方法都加入锁。在方法中加入synchronized，虽然实现了线程之间的同步，但是却降低了多线程的并发能力，如果一个方法中，仅仅只有一行代码需要同步，那么使用同步方法将会锁住整个方法，导致其他线程无法访问。所以在java中，支持同步代码块。语法也很简单，如下所示：
public void addName(String name) {
synchronized(this) {
lastName = name;
nameCount++;
}
nameList.add(name);
}

原子访问（Atomic Access）

在编程中，一个原子的动作，是不可分割的。类似于数据库中的原子操作，所有操作要么执行成功，要么执行失败，不存在半执行。在java中，大部分的原始数据类型的操作都是原子的，或者是加入了volatile关键字的域。一般而言，使用原子技术会让代码更加难以控制，理解起来也更加困难，所以应该避免大范围的使用。

死锁（Deadlock）

死锁就是两个线程互相等待对方的完成。下面的例子就说明了，两个friend都在等待对方bowBack()，所以程序会一直无限期的进入等待。

public class Deadlock {
    static class Friend {
        private final String name;
        public Friend(String name) {
            this.name = name;
        }
        public String getName() {
            return this.name;
        }
        public synchronized void bow(Friend bower) {
            System.out.format("%s: %s"
                + "  has bowed to me!%n", 
                this.name, bower.getName());
            bower.bowBack(this);
        }
        public synchronized void bowBack(Friend bower) {
            System.out.format("%s: %s"
                + " has bowed back to me!%n",
                this.name, bower.getName());
        }
    }


    public static void main(String[] args) {
        final Friend alphonse =
            new Friend("Alphonse");
        final Friend gaston =
            new Friend("Gaston");
        new Thread(new Runnable() {
            public void run() { alphonse.bow(gaston); }
        }).start();
        new Thread(new Runnable() {
            public void run() { gaston.bow(alphonse); }
        }).start();
    }
}

下面我们通过代码来演示一个生产者-消费者关系。这里一共有三个线程，一个是生产者，另外一个是消费者，另外一个是主线程。生产者负责生产，然后每次生产完之后，都需要notify消费者来取数据，消费者负责消费数据，每次消费完之后，都notify生产者开始生产数据。需要注意的一点是，生产者和消费者都是访问同一个对象，在例子中就是

Drop对象。
//可以假设为生产线
public class Drop {
    // Message sent from producer
    // to consumer.
    private String message;
    // True if consumer should wait
    // for producer to send message,
    // false if producer should wait for
    // consumer to retrieve message.
    private boolean empty = true;


    public synchronized String take() {
        // Wait until message is
        // available.
        while (empty) {
            try {
                wait();
            } catch (InterruptedException e) {}
        }
        // Toggle status.
        empty = true;
        // Notify producer that
        // status has changed.
        notifyAll();
        return message;
    }


    public synchronized void put(String message) {
        // Wait until message has
        // been retrieved.
        while (!empty) {
            try { 
                wait();
            } catch (InterruptedException e) {}
        }
        // Toggle status.
        empty = false;
        // Store message.
        this.message = message;
        // Notify consumer that status
        // has changed.
        notifyAll();
    }
}


//生产者
import java.util.Random;


public class Producer implements Runnable {
    private Drop drop;


    public Producer(Drop drop) {
        this.drop = drop;
    }


    public void run() {
        String importantInfo[] = {
            "Mares eat oats",
            "Does eat oats",
            "Little lambs eat ivy",
            "A kid will eat ivy too"
        };
        Random random = new Random();


        for (int i = 0;
             i < importantInfo.length;
             i++) {
            drop.put(importantInfo[i]);
            try {
                Thread.sleep(random.nextInt(5000));
            } catch (InterruptedException e) {}
        }
        drop.put("DONE");
    }
}


//消费者
import java.util.Random;


public class Consumer implements Runnable {
    private Drop drop;


    public Consumer(Drop drop) {
        this.drop = drop;
    }


    public void run() {
        Random random = new Random();
        for (String message = drop.take();
             ! message.equals("DONE");
             message = drop.take()) {
            System.out.format("MESSAGE RECEIVED: %s%n", message);
            try {
                Thread.sleep(random.nextInt(5000));
            } catch (InterruptedException e) {}
        }
    }
}


//主线程
public class ProducerConsumerExample {
    public static void main(String[] args) {
        Drop drop = new Drop();
        (new Thread(new Producer(drop))).start();
        (new Thread(new Consumer(drop))).start();
    }
}

不可变对象

有时候，为了防止一些多线程问题的出现，可以使用不可变对象来代替可变对象。下面我们来看一个例子，一个颜色类。

public class SynchronizedRGB {


    // Values must be between 0 and 255.
    private int red;
    private int green;
    private int blue;
    private String name;


    private void check(int red,
                       int green,
                       int blue) {
        if (red < 0 || red > 255
            || green < 0 || green > 255
            || blue < 0 || blue > 255) {
            throw new IllegalArgumentException();
        }
    }


    public SynchronizedRGB(int red,
                           int green,
                           int blue,
                           String name) {
        check(red, green, blue);
        this.red = red;
        this.green = green;
        this.blue = blue;
        this.name = name;
    }


    public void set(int red,
                    int green,
                    int blue,
                    String name) {
        check(red, green, blue);
        synchronized (this) {
            this.red = red;
            this.green = green;
            this.blue = blue;
            this.name = name;
        }
    }


    public synchronized int getRGB() {
        return ((red << 16) | (green << 8) | blue);
    }


    public synchronized String getName() {
        return name;
    }


    public synchronized void invert() {
        red = 255 - red;
        green = 255 - green;
        blue = 255 - blue;
        name = "Inverse of " + name;
    }
}

这个类的getRGB()、getName()、invert()都是同步方法，但是还是可能会出现一些问题。比如下面的代码

SynchronizedRGB color =
    new SynchronizedRGB(0, 0, 0, "Pitch Black");
...
int myColorInt = color.getRGB();      //Statement 1
String myColorName = color.getName(); //Statement 2

在Stament1之后，如果一个线程在调用了getRGB()之后，另外一个方法调用set()方法，那么getName()和getRGB()得到的就不是同一个RGB颜色值了。那么我们如何防止这种情况的发生呢？没错，使用不可变对象的技术，去掉set()方法。

final public class ImmutableRGB {


    // Values must be between 0 and 255.
    final private int red;
    final private int green;
    final private int blue;
    final private String name;


    private void check(int red,
                       int green,
                       int blue) {
        if (red < 0 || red > 255
            || green < 0 || green > 255
            || blue < 0 || blue > 255) {
            throw new IllegalArgumentException();
        }
    }


    public ImmutableRGB(int red,
                        int green,
                        int blue,
                        String name) {
        check(red, green, blue);
        this.red = red;
        this.green = green;
        this.blue = blue;
        this.name = name;
    }




    public int getRGB() {
        return ((red << 16) | (green << 8) | blue);
    }


    public String getName() {
        return name;
    }


    public ImmutableRGB invert() {
        return new ImmutableRGB(255 - red,
                       255 - green,
                       255 - blue,
                       "Inverse of " + name);
    }
}

不可变对象的基本准则：
1、不提供setter方法修改fields
2、将所有fields变成private final
3、不允许子类override方法，可以使用final关键字修饰方法，或者使用private修饰
4、如果一个对象的field是一个引用对象，这个引用对象是可变的，那么就不允许修改该field，可以使用final修饰，并且不要将这个引用共享给其他对象，可以使用copy技术，将该引用对象的值赋值一份，再丢给其他对象。

使用java.util.concurrecy.*包来解决并发问题
在这个包中，有个很重要的抽象类，那就是Lock。这个方法的语义更加清晰，需要注意的一点就是，每次使用lock()之后，都需要在finally中，unlock()锁。下面使用Lock来改写前面死锁的例子：

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
import java.util.Random;


public class Safelock {
    static class Friend {
        private final String name;
        private final Lock lock = new ReentrantLock();


        public Friend(String name) {
            this.name = name;
        }


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


        public boolean impendingBow(Friend bower) {
            Boolean myLock = false;
            Boolean yourLock = false;
            try {
                myLock = lock.tryLock();
                yourLock = bower.lock.tryLock();
            } finally {
                if (! (myLock && yourLock)) {
                    if (myLock) {
                        lock.unlock();
                    }
                    if (yourLock) {
                        bower.lock.unlock();
                    }
                }
            }
            return myLock && yourLock;
        }
            
        public void bow(Friend bower) {
            if (impendingBow(bower)) {
                try {
                    System.out.format("%s: %s has"
                        + " bowed to me!%n", 
                        this.name, bower.getName());
                    bower.bowBack(this);
                } finally {
                    lock.unlock();
                    bower.lock.unlock();
                }
            } else {
                System.out.format("%s: %s started"
                    + " to bow to me, but saw that"
                    + " I was already bowing to"
                    + " him.%n",
                    this.name, bower.getName());
            }
        }


        public void bowBack(Friend bower) {
            System.out.format("%s: %s has" +
                " bowed back to me!%n",
                this.name, bower.getName());
        }
    }


    static class BowLoop implements Runnable {
        private Friend bower;
        private Friend bowee;


        public BowLoop(Friend bower, Friend bowee) {
            this.bower = bower;
            this.bowee = bowee;
        }
    
        public void run() {
            Random random = new Random();
            for (;;) {
                try {
                    Thread.sleep(random.nextInt(10));
                } catch (InterruptedException e) {}
                bowee.bow(bower);
            }
        }
    }
            


    public static void main(String[] args) {
        final Friend alphonse =
            new Friend("Alphonse");
        final Friend gaston =
            new Friend("Gaston");
        new Thread(new BowLoop(alphonse, gaston)).start();
        new Thread(new BowLoop(gaston, alphonse)).start();
    }
}

在java.util.concurrent.*中，还提供了线程执行器，这个接口就是Executor。在之前的代码中，我们使用(new Thread(r)).start()来启动线程，有了执行器之后，可以使用e.execute(r)来启动一个线程。在Executor中，有两个比较重要的子类，ExecutorService和ScheduledExecutorService，具体的使用方式也比较简单，大家可以直接查看java doc便可。

线程池（Thread Pools）

如果你熟悉jdbc的操作，那么肯定知道数据库连接池。有关于池的概念，都很类似，就是把一些需要的对象，事先准备好，然后将这些对象放入内存中，以后每次需要的时候，就直接从内存中取出来，这样子可以大大节省new一个对象的开销。在java中，提供了几个不一样的线程池供我们选择。
1、java.util.concurrent.Executors.newCachedThreadPool()提供一个缓存池
2、java.util.concurrent.Executors.newSingleThreadExecutor()提供一个单线程池
3、java.util.concurrent.Executors.newFixedThreadPool()提供一个固定大小的线程池

支持多线程的容器（Concurrent Collections）

在java.util.Collection中，提供了很多容器类，但是这些类大部分都不是线程安全的，所以如果程序需要使用线程安全的容器类，那么可以使用java.util.concurrent包中的容器类，这些类最大的区别就是线程安全的，所以使用上对我们来说没什么新的难点，直接查看文档api便可。

原子变量（Atomic Variables）

在之前的例子中，说到了原子访问，比如下面的计数器：

class Counter {
    private int c = 0;


    public void increment() {
        c++;
    }


    public void decrement() {
        c--;
    }


    public int value() {
        return c;
    }


}

一种方式可以让程序变得是线程安全的，一个是使用线程方法，如下代码：

class SynchronizedCounter {
    private int c = 0;
    public synchronized void increment() {
        c++;
    }
    public synchronized void decrement() {
        c--;
    }
    public synchronized int value() {
        return c;
    }
}

但是这种方式的效率不高，可以使用java.util.concurrent.atomic的原子类，如下代码：

import java.util.concurrent.atomic.AtomicInteger;


class AtomicCounter {
    private AtomicInteger c = new AtomicInteger(0);
    public void increment() {
        c.incrementAndGet();
    }
    public void decrement() {
        c.decrementAndGet();
    }
    public int value() {
        return c.get();
    }
}

总结：多线程的技术，一直是我们既向往又害怕的部分。向往是因为多线程的威力，害怕的是多线程的复杂性。在学习初，什么进程、线程、同步、原子、死锁等各种专业词汇搞得我们信心全无。只有不断的学习，总结，其实我们也可以掌握多线程。最后感谢大家的查询...继续苦逼写代码去了。

多线程的神秘面纱...还在恐惧吗？？？

标签：java

原文地址：http://blog.csdn.net/u010469003/article/details/42971249

踩

(0)

评论一句话评论（0）

分享档案

更多>

2021年07月29日 (22)
2021年07月28日 (40)
2021年07月27日 (32)
2021年07月26日 (79)
2021年07月23日 (29)
2021年07月22日 (30)
2021年07月21日 (42)
2021年07月20日 (16)
2021年07月19日 (90)
2021年07月16日 (35)

周排行