一，多线程
多线程是提高程序效率，避免资源浪费的很好的解决方案，下面来慢慢的介绍多线程的一些基本知识，而这些是晋级高级不可或缺的一部分
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,总之，要同步互斥的几段代码最好是分别放在几个独立的方法中，这些方法再放到同一个类中，这样比较容易实现他们之间的同步互斥和通信