JAVA 之"线程"

1、进程与线程：

     《1》什么是进程：是指运行中的应用程序，每一个进程都有自己独立的内存空间，

          一个应用程序可以同时启动多个进程，(静态)比如（IE，JVM）

     《2》什么是线程：是指进程中的一个执行流程，有时有称之为执行情景，

          一个进程有多个线程组成(动态)

     《3》进程与线程的主要区别：

          每个进程都需要操作系统为其分配独立的内存地址空间，

          而同一进程中的所有线程在同一块地址空间中工作，

          这些线程可以共享同 一块内存和系统资源

2、线程的创建(两种方式)：

     《1》继承Thread类（一般在不继承其他类的情况下）

     《2》实现Runnable接口（一般在继承其他类的情况下）

     

3、线程创建的步骤:

     《1》第一种

            (1)自定义线程类继承Thread类；

            (2)覆盖Thread类中的run()方法；

            (3)创建该线程类对象；

            (4)调用该线程类对象中的start()方法启动线程。

     《2》第二种

            (1)自定义线程类实现Runnable接口；

            (2)覆盖Runnable接口中的run()方法；

            (3)创建该线程类对象；

            (4)创建Thread对象，构造参数为该线程类对象；

            (5)调用Thread对象中的start()方法启动线程。

4、线程的实际应用以及注意事项：

     《1》主线程与用户自定义线程并发执行；

     《2》多个线程共享同一个对象的实例变量；

     《3》不要随便覆盖Thread类中的start()方法

              如果一定要覆盖start()方法，那么就首先调用super.start()方法；

     《4》一个线程只能被启动一次；

     《5》一般涉及操作同一个数据的程序，不使用多线程并发执行，

              以保证数据的安全性。

5、两个线程交互执行：

     《1》两个线程需要有同一个标记锁；

     《2》两个线程中的代码要用 synchronized 修饰。   

  

6、实例代码：

    利用两个线程的交互执行打印 A 1 2 B 3 4 C 5 6……

 

[java] view
plaincopy

package day5;  

  

public class ThreadT {  

    public static void main(String[] args) {  

        Object obj = new Object();  

        // 创建、启动通过继承Thread类来得到的线程  

        //给对象一个obj的标记锁  

        ThreadA ta = new ThreadA(obj);  

        ta.start();  

        // 创建、启动通过实现Runnable接口得到的线程  

        //给对象一个obj的标记锁  

        ThreadB tb = new ThreadB(obj);  

        Thread th = new Thread(tb);  

        th.start();  

    }  

}  

  

class ThreadA extends Thread {  

    private Object obj;  

  

    public ThreadA(Object obj) {  

        super();  

        this.obj = obj;  

    }  

  

    public void run() {  

        // 带有标记锁的代码，只有拿到标记锁才运行  

        synchronized (obj) {  

            for (char i = 'A'; i <= 'Z'; i++) {  

                System.out.print(i + " ");  

                // 唤醒队列中所有对象  

                obj.notifyAll();  

                try {  

                    if (i != 'Z') {  

                        // 放入等待队列  

                        obj.wait();  

                    }  

                } catch (InterruptedException e) {  

                    e.printStackTrace();  

                }  

            }  

        }  

    }  

  

}  

  

class ThreadB implements Runnable {  

    private Object obj;  

  

    public ThreadB(Object obj) {  

        super();  

        this.obj = obj;  

    }  

  

    public void run() {  

        // 带有标记锁的代码，只有拿到标记锁才运行  

        synchronized (obj) {  

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

                System.out.print(i * 2 - 1 + " ");  

                System.out.print(i * 2 + " ");  

                System.out.println();  

                // 唤醒队列中所有对象  

                obj.notifyAll();  

                try {  

                    if (i != 26) {  

                        // 放入等待队列  

                        obj.wait();  

                    }  

                } catch (InterruptedException e) {  

                    e.printStackTrace();  

                }  

  

            }  

        }  

  

    }  

  

}  

  
http://blog.csdn.net/anlisten/article/details/4842671