一，多线程
多线程是提高程序效率，避免资源浪费的很好的解决方案，下面来慢慢的介绍多线程的一些基本知识，而这些是晋级高级不可或缺的一部分
1，Thread类
类实现多线程需要实现Runnable接口，我们跟踪一下源码，如下所示：
public class Thread implements Runnable { /* Make sure registerNatives is the first thing <clinit> does. */ private static native void registerNatives(); static { registerNatives(); } ........ }
Thread类实现了Runnable的接口，然后我们来看一下Runnable接口里面有什么东西，如下所示，哦，原来就一个run方法
public interface Runnable { /** * When an object implementing interface <code>Runnable</code> is used * to create a thread, starting the thread causes the object's * <code>run</code> method to be called in that separately executing * thread. * <p> 意思是说，实现runnable的接口后的对象可以用来创建一个线程，并且这个线程是通过run方法来运行的 * The general contract of the method <code>run</code> is that it may * take any action whatsoever. * * @see java.lang.Thread#run() */ public abstract void run(); }
那么回过头来看看，Thread类中的重写的这个run方法是什么?
/**注意，这个注释的意思是说当用一个单独的Runnable对象来构造Thread线程的时候，Runnbalb对象的run方法将会被调用，否则，这个方法不起任何作用 * If this thread was constructed using a separate * <code>Runnable</code> run object, then that * <code>Runnable</code> object's <code>run</code> method is called; * otherwise, this method does nothing and returns. * <p> * Subclasses of <code>Thread</code> should override this method. * * @see #start() * @see #stop() * @see #Thread(ThreadGroup, Runnable, String) */ @Override public void run() { if (target != null) { target.run(); } }
那么，这个target是什么鬼？继续追踪
/* What will be run. */ private Runnable target;
好了，上面说的是背景知识，下面来真材实料吧。
初始化线程的方法有两个，
1，直接重写Thread类的run方法，注意，如果此时给Thread的构造函数传递一个Runnable对象，这个runnable对象的run方法不起任何作用，因为重写的run方法没有调用父类的run方法
2，直接给Thread传递一个runnable对象，调用对象的run方法
方法1：
Thread tr = new Thread(){ @Override public void run() { while(true){ try { Thread.sleep(500); } catch (InterruptedException e) { // TODO Auto-generated catch block e.printStackTrace(); } System.out.println("thread test"); } } }; tr.start();
方法2：
Thread tr2 = new Thread(new Runnable() { @Override public void run() { while(true){ try { Thread.sleep(500); } catch (InterruptedException e) { // TODO Auto-generated catch block e.printStackTrace(); } System.out.println("runnable test"); } } }){}; tr2.start();
针对方法1，我们这有一个小小的验证
当我们同时传递一个runnable对象和重写run方法时，结果会怎样呢？很明显，重写的run方法后，不会调用原来的那个target相关的操作了，也就是说传递进去的runnable没任何作用了，下面验证一下：
new Thread(new Runnable() { @Override public void run() { while(true){ try { Thread.sleep(500); } catch (InterruptedException e) { // TODO Auto-generated catch block e.printStackTrace(); } System.out.println("in runnbale"); } } }){ @Override public void run() { while(true){ try { Thread.sleep(500); } catch (InterruptedException e) { // TODO Auto-generated catch block e.printStackTrace(); } System.out.println("in thread"); } } }.start(); }
运行结果是：
in thread
in thread
in thread
in thread
in thread
in thread
in thread
二，定时器
这里主要介绍
Timer和TimerTask两个类
Timer类是声明一个定时器类，声明的时候可以给这个类提供一个TimerTask类的对象，注意，我们追踪一下这个TimerTask类，看到源码如下：
public abstract class TimerTask implements Runnable { public abstract void run(); ................ }
也就是说，这个类继承了runnable接口，意思就是说这个类最终是要生成一个Thread来进行TimerTask里面的run方法的。由此可见，定时器就是定时生成一个新的线程，然后这个新线程来执行run方法里的操作来的。
至于Timer里不同的构造参数，可以参考sdk里面的相关内容来学习。定时器就讲到这里了。
三，线程互斥
在实际生活中，我们会出现很多线程使用一个资源的问题，这些线程可能会抢夺资源，或者在某一时间段内，只能一个线程来使用资源，这个时候我们就需要用synchronized来进行线程间的互斥，下面来介绍一下线程互斥的问题
首先，我们建一个类，或者在一个类里将可能共同访问的资源给他一把锁，锁住这个资源，如下所示
public class test { public void displayit(String name) { synchronized (this) { for (int i = 0; i < name.length(); i++) { System.out.print(name.charAt(i)); } System.out.println(); } } }
这个锁就是synchronized，锁住的是test这个对象，也就是说对这个对象的访问都需要看看这个对象是否已经被锁住
下面，我们开两个线程，来一直不停的访问这个对象，并输出访问内容，如下所示
public void init() { final test2 t = new test2(); new Thread(new Runnable() { @Override public void run() { while (true) { try { Thread.sleep(10); t.displayit("leeyangyang"); } catch (InterruptedException e) { e.printStackTrace(); } } } }).start(); new Thread(new Runnable() { @Override public void run() { while (true) { try { Thread.sleep(10); t.displayit("weijunjun"); } catch (InterruptedException e) { e.printStackTrace(); } } } }).start(); }
然后我们在main方法里调用这个方法
public class Sync { /** * @param args */ public static void main(String[] args) { new Sync().init(); } .............................. ｝
最后我们得到的结果是：
leeyangyang
weijunjun
leeyangyang
weijunjun
然后再引伸一下，如果传递进去的是静态类，那么锁住的应该是什么参数呢？很明显，答案是静态类.class，具体的如下所示：
public static class test2 { public void displayit(String name) { synchronized (test2.class) { for (int i = 0; i < name.length(); i++) { System.out.print(name.charAt(i)); } System.out.println(); } } }
好了，线程互斥就介绍到这里了。
四，线程同步通信
进程间的通信是通过wait()和notify()来实现的，当等待一个资源时，用wait()方法，使用后，注意将资源释放或者重新标注一下，如下面所示，要实现的是子线程跑10次，然后主线程跑10次，然后子线程再跑10次，主线程跑10次，这样，一共持续50遍。
思路：
1，先实现主线程和子线程都跑10次50遍，
2，根据互斥规则，跑得时候，两者互不打扰
3，给一个信号，当子线程正在执行的时候，主线程会在等待，子线程执行完之后，通知一下等待的线程，然后主线程得到这个通知后，开启线程。
看下面代码：
public class Synch2 { public static void main(String[] args) { new Synch2().init(); } public void init() { final test2 t = new test2(); // 现开启一个子线程，然后根据子线程 new Thread(new Runnable() { @Override public void run() { for (int i = 1; i <= 50; i++) { t.sub(i); } } }).start(); for (int i = 1; i < 50; i++) { synchronized (Synch2.class) { t.maintest(i); } } } public class test2 { boolean subUsed = true; public synchronized void sub(int i) { while (!subUsed) { try { this.wait(); } catch (InterruptedException e) { e.printStackTrace(); } } for (int j = 0; j < 10; j++) { System.out.println("inn the subthread, num=" + j + " and loop " + i); } subUsed = false; this.notify();// 通知所有的正在等待的线程 } public synchronized void maintest(int i) { while (subUsed) { try { this.wait(); } catch (InterruptedException e) { e.printStackTrace(); } } for (int j = 0; j < 10; j++) { System.out.println("inn the main thread, num=" + j + " and loop " + i); } subUsed = true; this.notify(); } } }
这里有一个细节，就是在等待信号的时候，我们使用的是while,其实if也可以，但是我们使用的是while，原因是
可能其他原因导致了notify出现，但是while的条件仍不满足，这个时候，仍然会等待，但是如果是if的话，情况并不是这样
五，线程共享变量
线程内的变量在进行共享时，可以在外部新建一个map对，将变量放进去，然后，同一个线程内的对象可以共享变量
具体的代码如下
package cn.unis; import java.util.HashMap; import java.util.Map; import java.util.Random; public class SyncShare { final static Map<Thread , Object> maps = new HashMap<Thread, Object>(); public static void main(String[] args) { new SyncShare().init(); } public void init(){ new Thread(new Runnable(){ @Override public void run() { int data = new Random().nextInt(100); maps.put(Thread.currentThread(), data); new a().display(); new b().display(); } }).start(); new Thread(new Runnable(){ @Override public void run() { int data = new Random().nextInt(100); maps.put(Thread.currentThread(), data); new a().display(); new b().display(); } }).start(); } public static class a{ public void display(){ System.out.println(Thread.currentThread().getName()+" get a data is " + maps.get(Thread.currentThread())); } } public static class b{ public void display(){ System.out.println(Thread.currentThread().getName()+" get b data is " + maps.get(Thread.currentThread())); } } }
执行效果如下
Thread-0 get a data is 73 Thread-1 get a data is 89 Thread-0 get b data is 73 Thread-1 get b data is 89
六，多线程访问共享对象和数据的方式
分为两种情况，
1，每个线程执行的代码相同，比如说售票系统等，可以使用同一个runnable对象，这个runnable对象中有那个共享数据
2，每个线程执行的代码不同，比如说一个相加，一个相减，这个时候就需要不同的runnable对象，具体的可以分为下面几种数据共享的方式
a,将共享数据封装带另外一个对象中，然后将这个对象逐一传递给各个runnable对象。每个线程对共享数据的操作方法也分配到那个对象身上去完成，这样容易实现针对该数据斤西瓜的每个操作的互斥和通信。
b,将这些runnable对象作为某一个类中的内部类，共享数据作为这个外部类中的成员变量，每个线程对共享数据的操作方法也分配给外部类，以便实现对共享数据进行的各个操作的互斥和通信，作为内部类的各个runnable对象调用外部类的这些方法
c,上面两种方法的组合，将共享数据封装到另外一个对象中，每个线程对共享数据的操作方法也分配到那个对象身上去完成，对象作为这个外部类中的成员变量货方法中的局部变量，每个线程的runnale 对象作为外部类中的成员内部类和局部内部类
d,总之，要同步互斥的几段代码最好是分别放在几个独立的方法中，这些方法再放到同一个类中，这样比较容易实现他们之间的同步互斥和通信