JAVA线程

线程：线程是在进程内部同时做的事情

---

1.继承线程类

public class KillThread extends Thread{
    private Hero h1;
    private Hero h2;
    public KillThread(Hero h1, Hero h2){
        this.h1 = h1;
        this.h2 = h2;
    }
    public void run(){
        while(!h2.isDead()){
            h1.attackHero(h2);
        }
    }
}
public static void main(String[] args) {
         
        Hero gareen = new Hero();
        gareen.name = "盖伦";
        gareen.hp = 616;
        gareen.damage = 50;
 
        Hero teemo = new Hero();
        Hero bh = new Hero();
        Hero leesin = new Hero();
         
        KillThread killThread1 = new KillThread(gareen,teemo);
        killThread1.start();
        KillThread killThread2 = new KillThread(bh,leesin);
        killThread2.start();
    }

2.实现Runnable接口

public class Battle implements Runnable{
private Hero h1;
private Hero h2;

public Battle(Hero h1, Hero h2){
    this.h1 = h1;
    this.h2 = h2;
}

public void run(){
    while(!h2.isDead()){
        h1.attackHero(h2);
    }
}
}

public class TestThread {

public static void main(String[] args) {
     
    Hero gareen = new Hero();
    gareen.name = "盖伦";
    gareen.hp = 616;
    gareen.damage = 50;
    Hero teemo = new Hero()；
    Hero bh = new Hero();
    Hero leesin = new Hero();
    
    Battle battle1 = new Battle(gareen,teemo);
    new Thread(battle1).start();
    Battle battle2 = new Battle(bh,leesin);
    new Thread(battle2).start();

}
}

3.创建匿名类

使用匿名类，继承Thread,重写run方法，直接在run方法中写业务代码
匿名类的一个好处是可以很方便的访问外部的局部变量。
前提是外部的局部变量需要被声明为final。(JDK7以后就不需要了)

public static void main(String[] args) {
      
    Hero gareen = new Hero();
    gareen.name = "盖伦";
    gareen.hp = 616;
    gareen.damage = 50;
    Hero teemo = new Hero()；
    Hero bh = new Hero();
    Hero leesin = new Hero();
             
    //匿名类
    Thread t1= new Thread(){
        public void run(){
            //匿名类中用到外部的局部变量teemo，必须把teemo声明为final
            //但是在JDK7以后，就不是必须加final的了
            while(!teemo.isDead()){
                gareen.attackHero(teemo);
            }              
        }
    };
     
    t1.start();
      
    Thread t2= new Thread(){
        public void run(){
            while(!leesin.isDead()){
                bh.attackHero(leesin);
            }              
        }
    };
    t2.start();
     
}

synchronized

 表示当前线程，独占 对象 someObject
当前线程独占 了对象someObject，如果有其他线程试图占有对象someObject，就会等待，直到当前线程释放对someObject的占用。
someObject 又叫同步对象，所有的对象，都可以作为同步对象
为了达到同步的效果，必须使用同一个同步对象
	 synchronized (someObject) {      
                        System.out.println( now()+this.getName()+ " 占有对象：someObject");
                        Thread.sleep(5000);
                        System.out.println( now()+this.getName()+ " 释放对象：someObject");
                    }

线程安全

HashMap和Hashtable都实现了Map接口，都是键值对保存数据的方式
区别1：
HashMap可以存放 null
Hashtable不能存放null
区别2：
HashMap不是线程安全的类
Hashtable是线程安全的类

StringBuffer 是线程安全的
StringBuilder 是非线程安全的
所以当进行大量字符串拼接操作的时候，如果是单线程就用StringBuilder会更快些，如果是多线程，就需要用	  StringBuffer 保证数据的安全性
Vector是线程安全的类，而ArrayList是非线程安全的