java线程小小总结

线程：简单的来说就是程序的一个组成单元（也可以理解为程序里不同的执行路径）
进程：进程是有多个线程组成的，有多个线程共享进程里面的所有资源！显然管理线程比管理进程开销小的多！
创建每一个线程就生成一个负责管理当前线程的一个栈，专门管理当前线程！
里面多线程之前必须理解什么是多任务，在操作系统里面（假设是单个cpu的操作系统），就是通过时间片切换
cpu到不同的子任务，从微观上好像单个任务在执行，但是从宏观上是多个任务在执行，因为cpu的执行速度很快，
让我们感觉不到吧了！线程的执行是没有保障的，因为它会随着硬件设备的不同执行结果不一样，当然还有很多的
因素可以影响到线程的执行，比如可以通过调用sleep(),wait(),还有设置优先级等方法来实现！
2：java线程的创建
在java里面有两种方式可以新建线程
1：通过继承Thread的方式
publc class ThreadA extends Thread{
public static void main(String[] args){
ThreadA th = new ThreadA();
th.start();
}
public void run(){

}
}
2：通过实现Runnable()接口实现(通过方法匿名内部类)

public class ThreadB implements Runnable{
public static void main(String[] args){
Thread th = new Thread(new ThreadB(){
public void run(){
System.out.println("线程开始运行了");
}
});
}
}
不管是用哪一种方式都必须调用start方法，也就是让线程进行启动，通过Thread t= new Thread()这个时候得出来的
线程还是不能过允许的，因为jvm还没给他分配时间，资源等，必须通过调用start方法以后线程的状态才能进转换为运行
态，这个时候就需要里面线程的状态了：
刚开始new 的时候 只能是新建态到start以后是活动态，当线程执行到一段时间以后，突然因为io输入等而变成阻塞态，
同时线程可能被挂起，变成就绪态，最后到时间片到的时候可能变成又变成运行态！

线程状态在java中主要有以下几个方法来进行控制:

Sleep();让线程休眠的一段时间，单位为妙
join();让线程协作，也就是先让一个线程执行，执行完以后，继续执行当前线程
wait();让线程进入就绪状态，执行调用notify()或者是notifyAll()为止
setPriority();设置线程的优先级
yield(); 让出当前线程，自己变成就绪状态
interrupt() ；中断线程
boolean isAlive() ;测试线程是否是活动的
boolean isDaemon() 测试线程是否是守护线程


线程的同步：线程的同步主要是利用线程锁机制，大体实现方法为：

synchronized(this){ //在执行代码块过程中，不会被其他线程打断
...
}


或者是public synchronized void method();


线程一个小小的解析：
class ThreadTest extends Thread{
public void run() {
System.out.println ("someting run here！");
}
public void run(String s){
System.out.println ("string in run is " + s);
}
public static void main (String[] args) {
ThreadTest tt = new ThreadTest();
tt.start();
tt.run("it won't auto run!");
}
}


输出结果是string in run isit won't auto run!
someting run here

主要是因为一单调用start，就需要给点时间给jvm配置进程(根据不同的硬件设备产生的结果不一样)，这个时候，重构方法run就执行了！执行完成以后就开始执行run方法了
当然如果加上一个for(int i=0;i<10000;i++)这杨的话，jvm配置进程完成以后就执行后面的语句了！
注意理解join();其意思就是限制性完一个以后在执行别的
public class ThreadTest implements Runnable {
public static int a = 1;

public void run() {
for (int k = 0; k < 5; k++) {
a = a + 1;
}
System.out.println(Thread.currentThread().getName()+":"+a);
}

public static void main(String[] args) throws Exception {
Runnable r = new ThreadTest();
Thread t = new Thread(r);
Thread t2 = new Thread(r);
t.start();
t.join();
t2.join();
t2.start();
t2.join();
System.out.println("好");
}
}

由上面可知道先执行完t1在执行t2在执行system.out.println("好");

说明wait方法与notify方法必须在同步块内执行,即synchronized(obj之内).
wait是暂时释放对象锁，待需要用这个锁的对象使用，并且阻塞当前线程，待使用完成以后通过 notify()或者notifyAll()来进行通知我，也就是把锁换给我！
再继续下面的线程的代码！


一个用于synchronized语句中的对象称为一个监视器，当一个线程获得了synchronized(object)语句中的
代码块的执行权，就意味着它锁定了监视器。在一个时间内，只能有一个线程可以锁定监视器。所以其他的线
程在试图进入监视器前都将被挂起，直到锁定了监视器的线程执行完毕，监视器被解锁。并且一个刚锁定了
监视器的线程被解锁后，可以马上再次进入并锁定同一监视器。有了监视器的概念，再来看看下面几个方法
的含义：
wait：告诉当前线程放弃监视器并进入睡眠状态，直到其他线程进入同一监视器并调用notify为止。
notify：唤醒同一对象监视器中调用wait的第一个线程。用于类似饭馆有一个空位后通知所有等候就餐
的顾客中的第一位可以入坐的情况。
notifyAll：唤醒同一对象监视器中调用wait的所有线程，具有最高优先级别的线程首先被唤醒并执行。
用于某个不定期的培训班终于招生满额后，通知所有学员来上课的情况，先到达的，会先安排住宿。
synchronized（this或者是对象名）{

}

表示想执行方块内的代码必须先得到对象这把锁，不然永远执行不了！
this表示当前的对象，当然也可以写别的！
对象名，wait()表示释放这把锁，然后由需要等待这把锁的用户得到，得到以后在通过notify(),notifyAll();