JAVA多线程笔记

线程与进程：

一个程序至少有一个进程,一个进程至少有一个线程.  

 

进程

是一个正在执行的程序，每个进程执行都有一个执行顺序，也叫执行路径，或者控制单元。

进程在执行过程中拥有独立的内存单元

线程

是一个进程中的一个控制单元，线程控制着进程的执行

多个线程共享内存，极大地提高了运行效率

 

在windows环境下JVM启动的时候会有一java.exe进程。该进程至少有一线程负责java程序的执行，该线程的代码存在于main方法中，main方法作为java程序初试线程的起点，其他的任何线程都是由这个初始线程启动的。

 

JVM有两种线程：守护线程和非守护线程，守护线程是有JVM自己使用的，比如垃圾回收机制。Java的初试线程是非守护线程。

 

多线程的意义在于，在一个应用程序中，可以有多个部分同时执行，而操作系统并没有将多个线程看做独立的应用，以实现进程的调度、管理和资源的分配。

 

线程的创建：

1)  方法一：定义类继承java.lang.Thread，复写 run() 方法，通过实例化对象调用 start() 方法。

public void start()

l  使该线程开始执行；Java 虚拟机调用该线程的 run 方法。

l  结果是两个线程并发地运行；当前线程（从调用返回给 start 方法）和另一个线程（执行其 run 方法）。

l  多次启动一个线程是非法的。特别是当线程已经结束执行后，不能再重新启动。

代码示例：

class ThreadDemo extends Thread

{

    public void run() 

    {

        for(int i=0; i<1000; i++) {

            System.out.println("run---");

        }

    }

}

public class TestThread

{

    public static void main(String [] args) {

        ThreadDemo td = new ThreadDemo();

        td.start();

        for(int i=0; i<1000; i++) {

            System.out.println("main---");

        }

    }

}

 

2)  方法二：

声明实现 java.lang.Runnable 接口的类。该类然后实现 run 方法。然后可以分配该类的实例，在创建 Thread 时作为一个参数来传递给一个新的Thread对象，然后通过start()方法启动一个线程。

public Thread(Runnable target)

分配新的 Thread 对象。这种构造方法与 Thread(null, target,gname) 具有相同的作用，其中的 gname 是一个新生成的名称。自动生成的名称的形式为 “Thread-”+n，其中的 n 为整数。

代码示例：

class ThreadDemo implements Runnable

{

    public void run() {

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

            System.out.println(Thread.currentThread()+"running");

        }

    }

}

public class Test

{

    public static void main(String [] args) {

        new Thread(new ThreadDemo()).start();

    }

}

两种线程的创建方式的对比：

方法一：继承Thread类

只能单继承Thread

存放在Thread子类的run()方法中

方法二：实现Runable接口

避免了单继承的局限性

存放在实现Runable接口类的run()方法中

 

线程的状态：

 

线程安全问题：

问题原因：

当多条语句在操作一个线程共享数据时，其中一个线程只对多条数据执行了一部分，还未执行完，另一线程启动，参与到共享数据中来，就会造成共享数据的错误。

解决办法：

操作线程，将操作共享数据的多条语句，在一个线程中全部执行完，执行过程中，其他线程不能参与。

Java提供了“同步代码块”来解决线程安全问题。

Synchronized (对象) {

   //多条语句

}

语句中的对象如同锁，持有锁的线程可以再同步中执行，没有取得锁的线程即使获得cpu执行权，也无法执行同步代码。

同步方法：

public void synchronized run() {

 

}

静态方法与成员方法的对象锁：

函数需要被对象调用，那么函数都有一个所属对象的引用，同步函数的锁是this。

同步函数被静态修饰时，使用的线程锁是该类的字节码文件对象，类.class

线程安全前提：

至少两个以上线程。

是否用的同一个线程。

单例模式：懒汉式

class Single

{

    private static Single s = null;

    private Single() {}

    public static Single getInstance() {

        if(s==null) {

            synchronized(Single.class) {

                if(s==null) {

                    s = new Single();

                }

            }

        }

        return s;

    }

}

 

线程间通信：

多个线程操作同一资源，但是操作的动作不同。

线程死锁问题：

两个线程同时使用相同的两个线程锁，但是每一个线程只拥有其中的一个线程锁，两个线程不放开自己的线程锁，于是便产生了线程死锁的问题。

等待唤醒机制：都使用在线程同步中，因为都要对持有对象锁的那个线程操作

l  publicfinal void wait() throwsInterruptedException

导致当前的线程等待，直到其他线程调用此对象的notify()方法或notifyAll()方法。换句话说，此方法的行为就好像它仅执行 wait(0) 调用一样。 当前的线程必须拥有此对象锁。

l public final void notify()

唤醒在此对象监视器上等待的单个线程。如果所有线程都在此对象上等待，则会选择唤醒其中一个线程。选择是任意性的，并在对实现做出决定时发生。线程通过调用其中一个 wait 方法，在对象的监视器上等待。

易错点： 直到当前的线程放弃此对象上的锁定，才能继续执行被唤醒的线程。并不是使用notify()；之后就执行新的线程，只有在当前线程放弃当前线程锁的时候，才随即选择等待在当前对象上的线程。

 

JDK1.5新特性

将同步关键字synchronized替换成现实Lock操作。Lock 替代了synchronized 方法和语句的使用，Condition 替代了 Object 监视器方法的使用。

注意：一定要进行线程解锁。

void await() 造成当前线程在接到信号或被中断之前一直处于等待状态。

假定调用此方法时，当前线程保持了与此 Condition 有关联的锁定。这取决于确定是否为这种情况以及不是时，如何对此作出响应的实现。通常，将抛出一个异常（比如 IllegalMonitorStateException）并且该实现必须对此进行记录。

void signal() 唤醒一个等待线程。

如果所有的线程都在等待此条件，则选择其中的一个唤醒。在从 await 返回之前，该线程必须重新获取锁定。

void signalAll()  唤醒所有等待线程。

如果所有的线程都在等待此条件，则唤醒所有线程。在从 await 返回之前，每个线程都必须重新获取锁定。

 

javaAPI示例：

 class BoundedBuffer {

   final Lock lock = new ReentrantLock();

   final Condition notFull  = lock.newCondition();

   final Condition notEmpty = lock.newCondition();

   final Object[] items = new Object[100];

   int putptr, takeptr, count;

   public void put(Object x) throws InterruptedException {

     lock.lock();

     try {

       while (count == items.length)

         notFull.await();

       items[putptr] = x;

       if (++putptr == items.length) putptr = 0;

       ++count;

       notEmpty.signal();

     } finally {

       lock.unlock();

     }

   }

   public Object take() throws InterruptedException {

     lock.lock();

     try {

       while (count == 0)

         notEmpty.await();

       Object x = items[takeptr];

       if (++takeptr == items.length) takeptr = 0;

       --count;

       notFull.signal();

       return x;

     } finally {

       lock.unlock();

     }

   }

 }

 

 

守卫线程：

守卫线程是JVM的后台线程，例如垃圾回收机制，随着JVM的线程启动而启动，JVM的所有非守卫线程结束而结束。

public final void setDaemon(boolean on)

将该线程标记为守护线程或用户线程。当正在运行的线程都是守护线程时，Java 虚拟机退出。

该方法必须在启动线程前调用。

该方法首先调用该线程的 checkAccess 方法，且不带任何参数。这可能抛出 SecurityException（在当前线程中）。

on - 如果为 true，则将该线程标记为守护线程。

 

 

线程的常用方法：

public final int getPriority()  返回线程的优先级。

public final void setPriority(int newPriority) 

更改线程的优先级。

首先调用线程的 checkAccess 方法，且不带任何参数。这可能抛出 SecurityException。

在其他情况下，线程优先级被设定为指定的 newPriority 和该线程的线程组的最大允许优先级相比较小的一个。

优先级：public static final int MIN_PRIORITY/NORM_PRIORITY/MAX_PRIORITY

public void interrupt()  中断线程。

public static void yield()  暂停当前正在执行的线程对象，并执行其他线程。

 

使用Executor（扩展）

通过使用java.util.concurrent包中的执行器（Executor）管理Thread对象，简化多线程编程。

Executor 在客户端和任务执行之间提供了一个间接层；与客户端直接执行任务不同，这个中介对象将执行任务。Excutor允许你管理异步任务的执行，而无须显示的管理线程的生命周期。

Excutor是启动任务的优选方法。

java.util.concurrent 下 接口 Executor

执行已提交的 Runnable 任务的对象。

此接口提供一种将任务提交与每个任务将如何运行的机制（包括线程使用的细节、调度等）分离开来的方法。通常使用 Executor 而不是显式地创建线程。

例如，可能会使用以下方法，而不是为一组任务中的每个任务调用 new Thread(new(RunnableTask())).start()：

 Executor executor = anExecutor;

 executor.execute(new RunnableTask1());

 executor.execute(new RunnableTask2());

 ...

构造方法

void execute(Runnable command)

在未来某个时间执行给定的命令。该命令可能在新的线程、已入池的线程或者正调用的线程中执行，这由 Executor 实现决定。

 

ExecutorService是具有生命周期的Executor。

代码示例

Import java.util.cincurrent.*;

class Thre implements Runnable

{

    public void run() {}

}

class ThreadTest

{

    public static void main(String[] args)

    {

        ExecutorService exec = Exectors.newCachedThreadPool();

;

        for(int i=0; i<5; i++) {

            exec.execute(new Thre());

            exec.shutdown();

        }

    }

}

 

java.util.concurrent

类 Executors:

此包中所定义的 Executor、ExecutorService、ScheduledExecutorService、ThreadFactory 和 Callable 类的工厂和实用方法。此类支持以下各种方法：

创建并返回设置有常用配置字符串的ExecutorService 的方法。

创建并返回设置有常用配置字符串的ScheduledExecutorService 的方法。

创建并返回“包装的”ExecutorService方法，它通过使特定于实现的方法不可访问来禁用重新配置。

创建并返回 ThreadFactory 的方法，它可将新创建的线程设置为已知的状态。

创建并返回非闭包形式的 Callable的方法，这样可将其用于需要 Callable 的执行方法中