多线程学习笔记

一、并行跟并发的区别

并行指在同一时刻,有多条指令在多个处理器上同时执行;并发指在同一时刻只能有一条指令执行,但多个进程指令被快速轮换执行,使得在宏观上具有多个进程同时进行的效果。对于一个CPU而言,他在某个时间点上只能执行一个程序,也就是说只能运行一个进程,CPU不断地在这些进程之间轮换执行。但是我们感觉不到任何中断现象,原因是CPU的执行速度相对我们的感觉太快了。

二、两种方式创建线程

创建线程有两种方式,一是继承Thread类,二是实现Runnable接口。如果采用Thread方式,其优势是访问当前线程时,无须使用Thread.currentThread()方法,直接使用this即可获得当前线程;劣势是其已经继承了Thread类,所以不能再继承其他父类。如果采用Runnable方式,其优势是实现Runnable接口的同时,还可以继承其他类,并且在这种方式相爱可以多个线程共享同一个target对象;劣势是访问当前线程,必须使用Thread.currentThread()方法。注:采用Runnable方式创建的对象只能作为线程对象的target。

package wbb.java.Thread;

/**
 * Created with IntelliJ IDEA.
 * User: wbb
 * Date: 14-7-11
 * Time: 上午9:54
 * Thread/Runnable两种方式创建进程
 */
public class ThreadAndRunnable {
    public static void main(String[] args) {
        ByThread thread = new ByThread();
        thread.start();
        //采用Runnable方式创建的对象只能作为线程对象的target。
        ByRunnable runnable = new ByRunnable();
        Thread t = new Thread(runnable);
        t.start();
    }
}

class ByThread extends Thread {
    public void run() {
        System.out.println(this.getName());
    }
}

class ByRunnable implements Runnable {
    public void run() {
        System.out.println(Thread.currentThread().getName());
    }
}

三、IllegalThreadStateException

测试某条线程是否已经死亡,可以调用线程对象的isAlive()方法,当线程处于就绪、运行、阻塞三种状态是,该方法将返回true;当线程处于新建、死亡两种状态时,该方法将返回false。警告:1、不要对一个线程调用两次start()方法;2、不要对一个已经死亡的线程调用start()方式使其重新启动。这两种做法都会导致IllegalThreadStateException异常。

package wbb.java.Thread;

/**
 * Created with IntelliJ IDEA.
 * User: wbb
 * Date: 14-7-11
 * Time: 上午10:11
 * 两种错误的做法导致IllegalThreadStateException
 */
public class ThreadException extends Thread {
    public void run() {
        System.out.println("123");
    }

    public static void main(String[] args) {
        ThreadException thread1 = new ThreadException();
        ThreadException thread2 = new ThreadException();

        //两次调用start()方法
        thread1.start();
        thread1.start();

        //试图对已经死亡的线程调用start()方法使其启动
        if(!thread2.isAlive()) {
            thread2.start();
        }
    }
}

四、join方法的作用

join()方法的作用是为了保证某个线程执行完毕后再往下执行其他线程。join(long millis)方法表示等待被join的线程的时间最长为millis毫秒。如果在millis毫秒内,被join的线程还没有执行结束则不再等待。
package wbb.java.Thread;

/**
 * Created with IntelliJ IDEA.
 * User: wbb
 * Date: 14-7-11
 * Time: 上午10:26
 * join方法的作用
 */
public class JoinThread extends Thread {
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println(this.getName());
        }
    }

    public static void main(String[] args) throws Exception {
        JoinThread thread1 = new JoinThread();
        thread1.setName("thread1");
        JoinThread thread2 = new JoinThread();
        thread2.setName("thread2");
        thread1.start();
        //保证线程thread1执行完毕后再往下继续执行
        thread1.join();
        thread2.start();
    }
}
如果没有添加join()来保证thrread1已经执行完毕的话,CPU会不停的无规律的轮换执行,所以会出现thread1、thread2交替执行的结果。如图:
多线程学习笔记

五、sleep()与yield()的区别

1、sleep()方法暂停当前线程后,会给其他线程执行机会,不需要理会其他线程的优先级。但是yield方法指挥给优先级相同,或者优先级更高的线程执行机会。
2、sleep()方法会将线程转入阻塞状态,直到经过阻塞时间才会转入就续状态。二yield不会将线程转入阻塞状态,他只是强制当前线程进入就绪状态。因此完全有可能某个线程嗲用yield()方法暂停之后,立即再次获得处理器资源被执行。
3、sleep()方法声明抛出了InterruptedException异常,而yield没有。
package wbb.java.Thread;

/**
 * Created with IntelliJ IDEA.
 * User: wbb
 * Date: 14-7-11
 * Time: 上午11:21
 */
public class SleepThread extends Thread {
    public SleepThread(String name) {
        super(name);
    }

    public void run() {
        for(int i=0;i<10;i++) {
            System.out.println(this.getName() + i);
            if(i == 3) {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    public static void main(String[] args) {
        SleepThread sleep1 = new SleepThread("Sleep-高优先级");
        SleepThread sleep2 = new SleepThread("Sleep-低优先级");
        sleep1.setPriority(Thread.MAX_PRIORITY);
        sleep2.setPriority(Thread.MIN_PRIORITY);
        sleep1.start();
        sleep2.start();
    }
}
运行效果如图,可以看出sleep方法对不会理会优先级的高低。多线程学习笔记

package wbb.java.Thread;

/**
 * Created with IntelliJ IDEA.
 * User: wbb
 * Date: 14-7-11
 * Time: 上午11:25
 * To change this template use File | Settings | File Templates.
 */
public class YieldThread extends Thread {
    public YieldThread(String name) {
        super(name);
    }

    public void run() {
        for(int i=0;i<10;i++) {
            System.out.println(this.getName() + i);
            if(i == 3) {
                Thread.yield();
            }
        }
    }

    public static void main(String[] args) {
        YieldThreadyield1 = new YieldThread("Yield-高优先级");
        YieldThreadyield2 = new YieldThread("Yield-低优先级");
        //设置优先级
        yield1.setPriority(Thread.MAX_PRIORITY);
        yield2.setPriority(Thread.MIN_PRIORITY);
        //启动两个并发线程
        yield1.start();
        yield2.start();
    }
}

运行效果如图,调用yield()方法后,执行机会会让给同级或更高级的线程。
多线程学习笔记















多线程学习笔记,布布扣,bubuko.com

多线程学习笔记

上一篇:Effective C++ Item 29 为”异常安全”而努力是值得的


下一篇:【工具类】JAVA 以行为单位读取文件并比对