5、进程与线程

进程与线程

1、  进程是程序的一次动态执行过程，它经历了从代码加载、执行到执行完毕的一个完整过程，这个过程也是进程本身从产生、发展到消亡的过程

2、  线程Thread是进程下更小的执行单位，同一进程下的多个线程可以同时执行，叫多线程

 

 

线程的使用

1、  线程可以通过继承Thread类或Runnable接口来实现，线程启动后会默认调用类中的run方法，如下

class MyThread extends Thread{

    private String name;

    public MyThread(String name){

        this.name = name;

    }

    //线程默认调用的方法

    publicvoid run(){

        for(int i=1; i<=10; i++){

            System.out.println(this.name +": "+ i);

        }

    }

}

 

2、  使用Thread定义线程，并使用

class MyThread extends Thread{

    private String name;

    public MyThread(String name){

        this.name = name;

    }

    publicvoid run(){

        for(int i=1; i<=10; i++){

            System.out.println(this.name +": "+ i);

        }

    }

}

 

publicclass hello{

    publicstaticvoid main(String args[]){

        MyThread t1 =new MyThread("thread one");

        MyThread t2 =new MyThread("thread two");

        t1.run();

        t2.run();

    }

}

执行后发现，程序在按顺序执行，显然多线程并没有启动。要启动线程，需要将t1.run()与t2.run()修改为t1.start()和t2.start()才可以，start表示启动线程，而线程启动后会直接去调用类中的run()方法。

 

3、  使用Runnable定义线程，并使用

class MyThread implements Runnable{

    private String name;

    public MyThread(String name){

        this.name = name;

    }

    publicvoid run(){

        for(int i=1; i<=10; i++){

            System.out.println(this.name +": "+ i);

        }

    }

}

 

publicclass hello{

    publicstaticvoid main(String args[]){

        MyThread t1 =new MyThread("thread one");

        MyThread t2 =new MyThread("thread two");

        Thread td1 =new Thread(t1);     //启动仍需通过Thread对象

        Thread td2 =new Thread(t2); //启动仍需通过Thread对象

        td1.start();

        td2.start();

    }

}

Runnable接口定义的线程如果要启动仍然需要通过Thread对象，这是主要的区别

 

4、  Thread类与Runable接口的区别

一个类如果继承了Thread类，则多线程不适合进行资源共享；而实现了Runnable接口则可以方便的实现资源共享

可以通过Thread.currentThread().getName()获取当前线程对象和线程名称

 

继承Thread类如下，共5张票，但是每个线程都卖出了5张票，这是不对的

class MyThread extends Thread{

    privateint ticket =5;

    publicvoid run(){

        for(int i=1; i<100; i++){

            if(ticket>0){

                System.out.println(Thread.currentThread().getName()

 +" sold ticket: "+ ticket--);

            }

        }

    }

}

 

publicclass hello{

    publicstaticvoid main(String args[]){

        //声明了两个线程对象，两个线程都拥有自己单独的资源

        MyThread t1 =new MyThread();

        MyThread t2 =new MyThread();

        //分别启动两个线程，因为两个线程的资源不是共享的

        //所以每个线程会发5张票，这就不对了

        t1.start();

        t2.start();

    }

}

 

实现Runnable接口的类如下，共5张票，两个线程共输出5张票，结果正确

通过Thread.currentThread()可获取当前线程对象

通过Thread.currentThread().getName()可以获取当前线程对象名

class MyThread implements Runnable{

    privateint ticket =5;

    publicvoid run(){

        for(int i=1; i<100; i++){

            if(ticket>0){

                System.out.println(Thread.currentThread().getName()

 +" sold ticket: "+ ticket--);

            }

        }

    }

}

 

publicclass hello{

    publicstaticvoid main(String args[]){

        //声明一个资源对象

        MyThread t1 =new MyThread();

        //启动两个线程，两个线程共享t1内的资源，实现资源共享

        Thread td1 =new Thread(t1);

        Thread td2 =new Thread(t1);

        td1.start();

        td2.start();

    }

}

 

 

JVM、进程与线程

1、  Java编写的程序都运行在jvm中，每一个程序启动时，都会启动一个JVM，这个JVM实际上就是进程

2、  一个java程序至少启动两个线程，一个是main函数线程，一个是程序的垃圾收集线程

 

 

线程状态

1、  创建：Thread t =new Thread();

2、  就绪：t.start();线程启动后就进入操作系统排队，排到了就调用run方法运行

3、  运行：t.run(); 由系统调用运行

4、  堵塞：sleep();suspend();wait()时，线程暂停执行

5、  死亡：stop()或run()结束时

 

 

线程同步与死锁

1、  实现了Runnable接口的类，类中的属性由多个线程共享，这时如果多个线程同时操作一个资源时就会出问题，所以出现了线程同步问题，如下

class MyThread implements Runnable{

    privateint ticket =5;

    publicvoid run(){

        for(int i=1; i<100; i++){

            if(ticket>0){

                try{

                    //sleep后线程紧密排队，导致资源争抢

                    Thread.sleep(300);

                }catch(Exception ex){

                    ex.printStackTrace();

                }

                System.out.println(Thread.currentThread().getName()+" sold ticket: "+ ticket--);

            }

        }

    }

}

 

publicclass hello{

    publicstaticvoid main(String args[]){

        MyThread t1 =new MyThread();

        Thread td1 =new Thread(t1);

        Thread td2 =new Thread(t1);

        td1.start();

        td2.start();

    }

}

 

2、  线程同步，指同一时间内，只允许一个线程对资源进行操作，其它线程排队直到前一个线程完成

 

3、  同步代码块，synchronized(同步对象){需同步代码}，如下

class MyThread implements Runnable{

    privateint ticket =5;

    publicvoid run(){

        for(int i=1; i<100; i++){

            //同步其中的代码块，防止资源争抢，一般使用this，意思是对当前对象进行同步

            //同一时间只允许一个线程访问this（当前）对象，而this对象中包含共享资源ticket

            synchronized(this){

                if(ticket>0){

                    try{

                        Thread.sleep(300);

                    }catch(Exception ex){

                        ex.printStackTrace();

                    }

                    System.out.println(Thread.currentThread().getName()+" sold ticket: "+ ticket--);

                }

            }

        }

    }

}

 

4、  同步方法，锁定了该方法同一时间只能有一个线程对其进行调用，如下

class MyThread implements Runnable{

    privateint ticket =5;

    publicvoid run(){

        for(int i=1; i<100; i++){

            sale();

        }

    }

    //同步方法，

    privatesynchronizedvoid sale(){

        if(ticket>0){

            try{

                Thread.sleep(300);

            }catch(Exception ex){

                ex.printStackTrace();

            }

            System.out.println(Thread.currentThread().getName()+" sold ticket : "+ ticket--);

        }

    }

}

 

 

同步与死锁

1、  当需要解决资源共享时，要使用同步来解决

2、  当同步过多时，会出现死锁问题