java多线程编程

一、概念

Java使用Thread类代表线程,所有的线程对象都必须是Thread类或其子类。

二、继承Thread类创建线程类步骤

  1. 定义Thread的子类,并重写run方法,该方法是线程需要完成的任务。
  2. 创建该子类的实例,即创建线程对象。
  3. 调用线程对象start()方法来启动线程。

三、同步代码块

  1. 多线程同时对资源进行访问时,同步机制使得同一时间内只能有一个线程对资源进行操作。
  2. 同步机制可以用Synchronized实现。
  3. 当Synchronized修饰一个方法的时候,该方法称为同步方法。
  4. 当Synchronized方法执行完成或者异常时会释放锁。

##synchronized修饰方法,静态方法

  1. synchronized修饰方法时,会对类实例进行加锁,该实例的所有synchronized方法必须等当前锁释放后才能访问。
  2. synchronized修饰静态方法时,会对类对象上锁,改类的其他实例的的synchronized方法必须等当前锁释放后才能访问。
  3. synchronized修饰对象时,会对对象上锁,其他使用该对象的synchronized方法必须等当前锁释放才能访问。

四、wait/notify

1. wait() 与 notify/notifyAll 方法必须在同步代码块中使用

2.wait() 与 notify/notifyAll() 的执行过程

当线程执行wait()时,会把当前的锁释放,然后让出CPU,进入等待状态。当执行notify/notifyAll方法时,会唤醒一个处于等待该 对象锁 的线程,然后继续往下执行,直到执行完退出对象锁锁住的区域(synchronized修饰的代码块)后再释放锁。

实例:

public class Service {

    public void testMethod(Object lock) {
        try {
            synchronized (lock) {
                System.out.println("begin wait() ThreadName="
                        + Thread.currentThread().getName());
                lock.wait();
                System.out.println("  end wait() ThreadName="
                        + Thread.currentThread().getName());
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public void synNotifyMethod(Object lock) {
        try {
            synchronized (lock) {
                System.out.println("begin notify() ThreadName="
                        + Thread.currentThread().getName() + " time="
                        + System.currentTimeMillis());
                lock.notify();
                Thread.sleep(5000);
                System.out.println("  end notify() ThreadName="
                        + Thread.currentThread().getName() + " time="
                        + System.currentTimeMillis());
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

从上面的代码可以看出,wait() 与 notify/notifyAll()都是放在同步代码块中才能够执行的。如果在执行wait() 与 notify/notifyAll() 之前没有获得相应的对象锁,就会抛出:java.lang.IllegalMonitorStateException异常。
接下来是两个线程类,线程类ThreadA调用testMethod()方法执行lock.wait();时被挂起,另一个线程类synNotifyMethodThread调用synNotifyMethod()负责唤醒挂起的线程。

public class ThreadA extends Thread {
    private Object lock;

    public ThreadA(Object lock) {
        super();
        this.lock = lock;
    }

    @Override
    public void run() {
        Service service = new Service();
        service.testMethod(lock);
    }
}

public class SynNotifyMethodThread extends Thread {
    private Object lock;

    public SynNotifyMethodThread(Object lock) {
        super();
        this.lock = lock;
    }

    @Override
    public void run() {
        Service service = new Service();
        service.synNotifyMethod(lock);
    }
}

再接下来是测试类:
public class Test {

    public static void main(String[] args) throws InterruptedException {

        Object lock = new Object();

        ThreadA a = new ThreadA(lock);
        a.start();

        //NotifyThread notifyThread = new NotifyThread(lock);
       // notifyThread.start();

        SynNotifyMethodThread c = new SynNotifyMethodThread(lock);
        c.start();
    }
}
# 线程  

评论

Your browser is out-of-date!

Update your browser to view this website correctly. Update my browser now

×