多线程学习笔记
时间：2014-07-12 21:09:25
收藏：0
阅读：208
一、并行跟并发的区别
并行指在同一时刻，有多条指令在多个处理器上同时执行；并发指在同一时刻只能有一条指令执行，但多个进程指令被快速轮换执行，使得在宏观上具有多个进程同时进行的效果。对于一个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()方法后，执行机会会让给同级或更高级的线程。
评论（0）