进程和线程

1.进程和线程

进程是个静态的概念,一个进程就是一个执行中的程序,而每一个进程都有自己独立的一块内存空间,一组系统资源.在进程概念中,每一个进程的内部数据和状态都是完全独立的.比如机器上的一个class文件或者一个exe文件.

线程是个动态的概念,在我们机器上运行的都是线程.线程是程序中单个顺序的流控制.同类的多个线程是共享一块内存空间和一组系统资源,而线程本身的数据通常只有微处理器的寄存器数据,以及一个供程序执行时使用的堆栈.

 

2.线程的两种实现方法

   1>.继承Thread

public class MyThread_1 extends Thread{
    public void run(){
        //some code 
    }
} 

当使用继承创建线程，这样启动线程：new MyThread_1().start()

   2>.实现Runnable接口

public class MyThread_2 implements Runnable{
    public void run(){
        //some code 
    }
} 

当使用实现接口创建线程，这样启动线程：new Thread(new MyThread_2()).start()

 

3.线程设置优先级

public void static main(String[] args){ . . . . . . Thread t2=new Thread(new MyThread()); t2.setPriority(Thread.MAX_PRIORITY);//赋予最高优先级 . . . . . . } 

线程的优先级分为10级，分别用1到10的整数代表，默认情况是5。

 

4.sleep() 和 wait()

public void run(){ . . . . . . int sleepTime=(int)(Math.random()*100);//产生随机数字， Thread.currentThread().sleep(sleepTime);//让其休眠一定时间，时间又上面sleepTime决定 . . . . . . } 

sleep是线程类（Thread）的方法，导致此线程暂停执行指定时间，给执行机会给其他线程，但是监控状态依然保持，到时后会自动恢复。调用sleep不会释放对象锁。
wait是Object类的方法，对此对象调用wait方法导致本线程放弃对象锁，进入等待此对象的等待锁定池，只有针对此对象发出notify方法（或notifyAll）后本线程才进入对象锁定池准备获得对象锁进入运行状态。

 

5.用synchronized(Object o)块来实现线程同步

 

class MyThread_1 extends Thread{
    Object lock;
    public MyThread_1(Object o){
        lock=o;
    }
    public void run(){
        try{
            synchronized(lock){
                System.out.println("Enter Thread_1 and wait");
                lock.wait();
                System.out.println("be notified");
            }
        }catch(InterruptedException e){}
    }
}
class MyThread_2 extends Thread{
    Object lock;
    public MyThread_2(Object o){
        lock=o;
    }
    public void run(){
        synchronized(lock){
            System.out.println("Enter Thread_2 and notify");
            lock.notify();
        }
    }
}

public class MyThread{ 
    public static void main(String[] args){
        int[] in=new int[0];//notice
        MyThread_1 t1=new MyThread_1(in);
        MyThread_2 t2=new MyThread_2(in);
        t1.start();
        t2.start();
    }
}
 

执行结果如下：
Enter Thread_1 and wait
Enter Thread_2 and notify
Thread_1 be notified

syncronized(Object obj)关键是同过传相同的锁对象来使得多线程程序的运行结果可控制.
wait and notify方法是Object中的，并不在Thread这个类中。最后你可能注意到了这点：int[] in=new int[0];为什么不是
创建new Object而是一个0长度的数组，那是因为在java中创建一个0长度的数组来充当锁更加高效。

Thread作为java中一重要组成部分，当然还有很多地方需要更深刻的认识，上面只是对Thread的一些常识和易错问题做了一个简要的总结，若要真正的掌握java的线程，还需要自己多做总结。