java进程/线程;堆和栈；多线程

一.进程和线程

进程：在内存中运行的应用程序，一个exe是一个进程。

如：ps -exf  可以查看各个应用的进程，其中ppid为父进程；

ps aux | egrep '(cron|syslog)'      找出与 cron 与 syslog 这两个服务有关的 PID 号码  ；

kill -9 进程id 可以关闭该进程

线程：进程中的一个执行流程，共享同一个进程的内存。

二.堆与栈

堆内存：存放new出来的对象和数组，分出的内存由jvm的自动垃圾回收器进行管理。

栈内存：定义一个变量，取值等于new出来的对象和数组的首地址，即取一个变量名，实际的值存在堆内存中，地址放在定义的变量中，该变量被称为数组或对象的引用变量

（堆保存实际数据，为属性内容，栈保存数值的空间地址，为对象名称）

例如：int[] a=new int a[10]  为堆内存分配一段连续的内存空间

a[2]=4   引用变量相当于给数组起个名字，以后可以引用

内存分配：

1.类变量（static修饰）：在堆中分配，堆中的内存地址存放在栈中，方便高速访问

2.实例变量：如   a[2]=4  ，作为堆对象的引用变量，引用完，被GC（garbage collection)垃圾回收器列入可回收的名单，但是不马上释放堆内存

3.局部变量：一般为for循环内定义，执行时在栈中开辟内存，脱离作用域后，内存释放，所以for内的变量一般定义在for内，而不是for外，防止占用内存

具体内存分配参照：http://blog.csdn.net/qh_java/article/details/9084091

三.线程与内存

Thread类实例是一个对象，有变量和方法，生死于堆上

每个线程实例有一个调用栈，每创建一个线程，就产生一个调用栈，记录函数执行顺序，开独立栈是为了并行运行

线程分类：1.用户进程 （main为主线程，其他线程为用户进程）

2.守护进程：程序运行时在后台提供一种通用服务的线程，如：垃圾回收线程，内存管理线程，数据库连接池监控线程

非守护线程结束，则守护线程没有存在的必要，此时jvm退出，守护线程也关闭！！

四.线程的生命周期

线程生命周期的五种状态：

（1）新建（new Thread）
当创建Thread类的一个实例（对象）时，此线程进入新建状态（未被启动）。
例如：Thread  t1=new Thread();

（2）就绪（runnable）
线程已经被启动，正在等待被分配给CPU时间片，也就是说此时线程正在就绪队列中排队等候得到CPU资源。例如：t1.start();

（3）运行（running）
线程获得CPU资源正在执行任务（run()方法），此时除非此线程自动放弃CPU资源或者有优先级更高的线程进入，线程将一直运行到结束。

当发生如下情况是，线程会从运行状态变为阻塞状态：

①、线程调用sleep方法主动放弃所占用的系统资源

②、线程调用一个阻塞式IO方法，在该方法返回之前，该线程被阻塞

③、线程试图获得一个同步监视器，但更改同步监视器正被其他线程所持有

④、线程在等待某个通知（notify）

⑤、程序调用了线程的suspend方法将线程挂起。不过该方法容易导致死锁，所以程序应该尽量避免使用该方法。

（4）死亡（dead）
当线程执行完毕或被其它线程杀死，线程就进入死亡状态，这时线程不可能再进入就绪状态等待执行。

自然终止：正常运行run()方法后终止

异常终止：调用stop()方法让一个线程终止运行

（5）堵塞（blocked）
由于某种原因导致正在运行的线程让出CPU并暂停自己的执行，即进入堵塞状态。

正在睡眠：用sleep(long t) 方法可使线程进入睡眠方式。一个睡眠着的线程在指定的时间过去可进入就绪状态。

正在等待：调用wait()方法。（调用motify()方法回到就绪状态）

被另一个线程所阻塞：调用suspend()方法。（调用resume()方法恢复）

状态控制和相关方法见：http://blog.csdn.net/lonelyroamer/article/details/7949969

五.如何创建多线程

多线程实现方式有2种：

（1）继承Thread类（单继承），并重写run方法

（2）实现Runnable接口（当创建的类继承了其他类时）

ps：为什么要单继承，多接口？--》防止继承的多个类中有相同的方法，不易区分，而接口没有方法体（多为抽象方法），可以多继承

先来编写一个单线程：

public class Mythread {
    @SuppressWarnings("static-access")
    public static void main(String[] args) {
         Thread t =Thread.currentThread();
         t.setName("单例线程");
         System.out.println(t.getName()+" 正在运行");
         for(int i=0;i<5;i++){
             System.out.println("线程正在休眠："+i);
             try {
                t.sleep(500);
            } catch (InterruptedException e) {
                System.out.println("线程出现错误了！！");
            }
         }

    }}

运行结果：

单例线程 正在运行
线程正在休眠：0
线程正在休眠：1
线程正在休眠：2
线程正在休眠：3
线程正在休眠：4

编写一个多线程，使用第一种方法：

package thread;

public class Mythread3 extends Thread {

    private String name;
    private int ms;

//封装线程名和时间

/*使用类方法，直接赋值类中的类方法，在该类被加载到内存时，就分配了相应的入口地址。
从而类方法不仅可以被类创建的任何对象调用执行，也可以直接通过类名调用。类方法的入口地址直到程序退出才被取消。
类方法在类的字节码加载到内存时就分配了入口地址，因此，Java语言允许通过类名直接调用类方法，而实例方法不能通过类名调用。*/
    public Mythread3(String name, int ms) {

        this.name = name;
        this.ms = ms;
    }

//  每个线程start()后进行run()
    @Override
    public void run() {
        // TODO Auto-generated method stub
    try {
        sleep(ms);

    } catch (InterruptedException e) {
        // TODO: handle exception
        System.out.println("线程出错啦");

    }
    System.out.println(name+"开始休眠"+ms);

    }

    public static void main(String[] args) {
        // TODO Auto-generated method stub

        Thread  t1=new Mythread3("线程1",100);
        Thread  t2=new Mythread3("线程2",300);
        Thread  t3=new Mythread3("线程3",200);
        t1.start();
        t2.start();
        t3.start();
    }
}

运行结果：

线程1开始休眠100
线程3开始休眠200
线程2开始休眠300

使用第二种方法：

package thread;

    class MyThread extends Thread{
        public int x = 0;
        public void run(){
        System.out.println(++x);
        }
        }

    class R implements Runnable{
        private int x = 0;
        public void run(){
        System.out.println(++x);
        }
        }

    public class Test{
         public static void main(String[] args){

         try {
          for(int i=0;i<10;i++){
          Thread t = new MyThread();  //Mythread类继承thread，使用方法（1），打印十次1
          t.start();
          }

          Thread.sleep(10000);//让上面的线程运行完成

          /*R类使用接口runnable，使用方法（2），10个线程对象产生的10个线程运行时打印了1到10。
          10个线程称为同一实例(Runnable实例)的多个线程。*/
          R r = new R();
          for(int i=0;i<10;i++){
          Thread t1 = new Thread(r);
           t1.start();
              }
         } catch (Exception e) {
          // TODO: handle exception
         }
        }
        }

运行结果：

 

六.线程同步

临界资源：多个线程共享的数据

java对象默认可以被多个线程共用，当用sychronized修饰时，则启动“互斥锁”机制，任一时刻只能由一个线程访问，即使该线程阻塞。

线程同步的方法有两种：

（1）synchronized(互斥锁）

（2）wait与notify

可见： http://blog.csdn.net/ff55c/article/details/6748604