java查漏补缺（2）

启动一个程序，是一个进程
一个进程内并行执行的是多个线程

这里以把同一个数循环50次加1为例。结果和预想有出入，请看线程同步部分。
想操作同一个数请把该数设为static!!!

设计一个类,继承Thread，并且重写run方法
启动线程办法：调用其start方法

public class AddThread1 extends Thread {
    private static Integer num = 0;

    public AddThread1(Integer num) {
        this.num = num;
    }

    public void add() throws InterruptedException {
        Thread.sleep(50);
        num = num + 1;
        System.out.println(currentThread().getName() + ":" + num);
    }

    @Override
    public void run() {
        for (int i = 0; i < 50; i++) {
            try {
                add();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

运行线程：

		AddThread1 addThread1 = new AddThread1(num);
        AddThread1 addThread11 = new AddThread1(num);
        addThread1.start();
        addThread11.start();

创建类，实现Runnable接口
启动的时候，首先创建一个对象，然后再根据该对象创建一个线程对象，并启动

public class AddThread2 implements Runnable {
    private static Integer num;
    public AddThread2(Integer num) {
        this.num = num;
    }
    public void add() throws InterruptedException {
        Thread.sleep(50);
        num = num + 1;
        System.out.println(Thread.currentThread().getName()+ ":" + num);
    }
    @Override
    public void run() {
        for (int i = 0; i < 50; i++) {
            try {
                add();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

运行线程：

		AddThread2 addThread2 = new AddThread2(num);
        new Thread(addThread2).start();
        new Thread(addThread2).start();

使用匿名类，继承Thread,重写run方法，直接在run方法中写业务代码
匿名类的一个好处是可以很方便的访问外部的局部变量。
运行线程：

public class ThreadTest {
    private static Integer num = 0;
    public static void main(String[] args) {
        Thread t1=new Thread(){
            @Override
            public void run() {
                add50();
            }
        };
        t1.start();
        Thread t2=new Thread(){
            @Override
            public void run() {
                add50();
            }
        };
        t2.start();
    }
    public static void add50(){
        for (int i=0;i<50;i++){
            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            num = num + 1;
            System.out.println(Thread.currentThread().getName()+ ":" + num);
        }
    }
}

sleep:表示当前线程暂停 ，其他线程不受影响

//休眠1000ms
Thread.sleep(1000);

join:即表明在主线程中加入该线程,主线程会等待该线程结束完毕， 才会往下运行。

public class TestThread {
    public static void main(String[] args) {
        Thread t1= new Thread(){
            public void run(){
                 //todo     
            }
        };
        t1.start();
        //代码执行到这里，一直是main线程在运行
        try {
            //t1线程加入到main线程中来，只有t1线程运行结束，才会继续往下走
            t1.join();
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }     
    } 
}

setPriority:优先级,当线程处于竞争关系的时候，优先级高的线程会有更大的几率获得CPU资源

		Thread t2= new Thread(){
            public void run(){
              //todo            
            }
        };
        t2.setPriority(Thread.MAX_PRIORITY);

yield:当前线程，临时暂停，使得其他线程可以有更多的机会占用CPU资源

		Thread t2= new Thread(){
            public void run(){
                //临时暂停，使得t1可以占用CPU资源
                Thread.yield();
         		//todo
            }
        };

setDaemon:当一个进程里，所有的线程都是守护线程的时候，结束当前进程。

		Thread t1= new Thread(){
            public void run(){
              	//todo             
            }
        };
        t1.setDaemon(true);
        t1.start();

上面三种创建线程的方式都是把同一个数0用两个线程循环50次加1，但最后结果都达不到100。
是因为其中一个线程加1的时候，另一个线程不是用的第一个线程加1以后的数据再加1，而是当前的数据，这个数据很可能还没加1。
解决办法有：使用synchronized、使用线程安全的类

所有需要修改数据的地方，有要建立在占有someObject的基础上。
而对象 someObject在同一时间，只能被一个线程占有。 间接地，导致同一时间，数据只能被一个线程修改。
这个 someObject就是个锁，要多个线程共用一个锁线程同步才会生效。

1. extends Thread 形式的线程同步：
   
2. 实现Runnable接口的由于是同一个AddThread2类的对象生成了两个线程，所以可以用本对象当锁。
   synchronized (this) {
   }
   表示当前对象为同步对象，即是addThread2为同步对象。
   
   
3. 匿名内部类用个obj就行
   

java中这种包装类的自动拆箱装箱特性导致的，在拆装箱的过程中实际上是new了一个新对象代替了原num对象，导致锁变了，如果没有装箱拆箱过程就可以用。
可使用线程安全的AtomicInteger。

在集合中，线程安全的有：HashTable,Vector
在包装类中，线程安全的有：StringBuffer，AtomicInteger等
非线程安全的类转换为线程安全的类：

ArrayList