Java Thread And Runnable

进程:它是程序的一次动态执行过程，它需要经历从代码加载，到代码执行，到执行完毕的一个完整过程，这个过程也是进程从产生、发展到最终消亡的过程。

线程:线程是比进程更小的执行单位，它是在进程的基础上进一步划分，所谓多线程，是指一个进程在执行的过程可以产生多个更小的程序单元，这些更小的单元-称为线程。这些线程可以同时存在，同时运行，一个进程可能产生多个同时执行的线程。

----------

java中进程的实现：

1、继承Thread类实现多线程:

package com.dyj.test;

public class TestThread extends Thread {

    private String myName;

    public TestThread(String myName) {
        this.myName = myName;
    }

    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println("运行了线程" + this.myName + "--" + i);    
        }
        
    }

    public static void main(String[] args) {
        TestThread testThread1 = new TestThread("a");
        TestThread testThread2 = new TestThread("b");

        testThread1.start();
        testThread2.start();
    }

}

运行结果(随机的):

　　　　运行了线程a--0
　　　　运行了线程a--1
　　　　运行了线程a--2
　　　　运行了线程a--3
　　　　运行了线程b--0
　　　　运行了线程b--1
　　　　运行了线程b--2
　　　　运行了线程b--3
　　　　运行了线程b--4
　　　　运行了线程a--4

另外一次：

　　　　运行了线程b--0
　　　　运行了线程b--1
　　　　运行了线程a--0
　　　　运行了线程b--2
　　　　运行了线程a--1
　　　　运行了线程b--3
　　　　运行了线程b--4
　　　　运行了线程a--2
　　　　运行了线程a--3
　　　　运行了线程a--4

从以上结果可以看出，两个线程的运行时交替的，那个线程先抢到CPU资源，哪个线程就可以运行，所以程序每次运行的结果都不一样，在线程启动的过程中，虽然调用的是start()方法，但是真正的运行的是run()方法定义的主体。

当重复的调用一个已经启动的线程-即重复的调用start方法:会抛出以下的异常信息

java.lang.IllegalThreadStateException
　　　　at java.lang.Thread.start(Thread.java:595)
　　　　　at com.dyj.test.TestThread.main(TestThread.java:23)

2、实现Runnable接口实现多线程:

package com.dyj.test;

public class TestThread implements Runnable {

    private String myName;

    public TestThread(String myName) {
        this.myName = myName;
    }

    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println("运行了线程" + this.myName + "--" + i);    
        }
        
    }
    
    public static void main(String[] args) {
        TestThread testThread1 = new TestThread("a");
        
        
        Thread t1 = new Thread(testThread1);
        Thread t2 = new Thread(testThread1);
        
        t1.start();
        t2.start();
    }

}

(注意:由于Runnable接口没有定义start方法，而在Thread类中，定义了一个构造器，可以传递Runnable的实现类，实例化一个Thread，调用它的start方法，进行线程的启动）

运行结果和继承Thread类结果类似，都是随机的结果，哪个线程抢到了CPU，就执行哪个类的线程。

实际上:继承Thread类和实现Runnable接口石油区别的，如果一个类继承Thread，则不适合于多个线程共享资源，相反如果一个类实现了Runnable接口，则可以实现资源的共享：因为可以

Thread t1 = new Thread(testThread1);
Thread t2 = new Thread(testThread1);
Thread t3 = new Thread(testThread1);

testThread1的属性可以实现共享。

---------------------------

线程的同步:所谓同步就是指多个操作，在同一个时间段内，只有一个线程可以运行，其他线程，要等待此线程执行完毕后，才可以继续执行，

1、同步代码块:是指用{}括起来的一段代码，根据其位置的不同：分为普通代码块，构造块，静态块，如果在代码块前面加上syschroized关键字，则此代码块，就称为同步代码块：语法如下:

syschroized(同步对象){
  需要同步的代码
} 
一般同步对象为this
syschroized(this){

  需要同步的代码
} 

2、同步方法。是指在返回值或者void前面添加关键字syschroized即可，就可以将该方法声明为同步方法：

线程的同步是以牺牲时间为代价的。