JAVA 之"线程"

来源：互联网发布：火影忍者av软件编辑：程序博客网时间：2024/06/10 03:00

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

1 0