学习笔记-线程

总结：

1：实现线程的方法有：继承Thread，实现Runable接口，继承Thread的匿名内部类

2：线程分用户线程，守护线程。程序中只有守护线程的时候就停止，不等守护线程执行完。用户线程可以被System.exit(0)强行终止。

3：可以用构造器参数或setName()设置线程的名字，默认名字为Thread-0，Thread-1。。。

4：线程的状态：新建，就绪（运行之前，等待CPU调度），运行，等待，堵塞，睡眠，死亡（不能重复运行的）

5：sleep()睡眠线程，减缓线程的执行速度，让出CPU执行其他线程；或周期型的执行代码。sleep()醒来后线程进入就绪状态而不是运行状态，所以不能用sleep()做精确的定时器。

6：yield()暂停线程，让当前运行线程进入就绪状态。也有可能立刻被CPU选中又进入运行状态。

7：t.join()等待t线程终止，运行该方法的线程才继续。内部由wait()方法实现，所以必须先取得锁，堵塞当前线程，然后让出锁。

8：synchronized同步。每个对象有一个锁，每个类有一个锁。

（1）

Public synchronized void methodAAA(){…}

等同于

Public void methodAAA(){synchronized (this){…}}

锁定的是调用这个同步方法对象。

（2）

private byte[] lock = new byte[0];  

零长度的byte数组对象创建起来将比任何对象都经济――查看编译后的字节码：生成零长度的byte[]对象只需3条操作码，而Object lock = new Object()则需要7行操作码。

（3）

两种方法都是锁定的类

Class Foo{

public synchronized static void methodAAA() 

{…}

public void methodBBB(){

synchronized(Foo.class) {…}

}

}

9：synchronized(b){...}；的意思是定义一个同步块,使用b作为资源锁。b.wait();的意思是临时释放锁，并阻塞当前线程,好让其他使用同一把锁的线程有机会执行,在这里要用同一把锁的就是b线程本身.这个线程在执行到一定地方后用notify()通知wait的线程,锁已经用完,待notify()所在的同步块运行完之后,wait所在的线程就可以继续执行.

 

匿名内部类实现线程

 

public class TestThread { public static void main(String[] args) { Thread t = new Thread(new Runnable() { public void run() { System.out.println("anonymous thread"); } }); t.start(); } }   

 

守护线程

例：守护线程不断的数数，直到主线程读入了一次输入结束，守护线程也就结束

public class DaemonThread extends Thread { public void run() { while (true) { for (int i = 1; i <= 100; i++) { this.setSleep(200); System.out.println(i); } this.setSleep(2000); } } public void setSleep(long time) { try { Thread.sleep(time); } catch (InterruptedException ex) { ex.printStackTrace(); } } public static void main(String[] args) { DaemonThread daemonThread=new DaemonThread(); //设为守护线程，用户线程全部结束之后程序结束，即使守护线程依然在执行 //javaGC是一个典型的守护线程 daemonThread.setDaemon(true); daemonThread.start(); try { System.in.read(); } catch (IOException e) { e.printStackTrace(); } } }

 

程序中只有守护线程存在的时候,是可以退出了

例：守护线程不断数数，主线程只输出一句话就结束，所以守护线程不执行完就结束

public class DaemonThread2 extends Thread { public void run() { for (int i = 1; i < 1000; i++) { System.out.println("Thread i:" + i); } } public static void main(String[] args) { try { Thread t = new DaemonThread2(); t.setDaemon(true); t.start(); System.out.println("main thread is over"); } catch (Exception ex) { ex.printStackTrace(); } } }

 

System.exit(0)可以强制终止线程

例：守护线程不断数数，主线程System.exit(0)后所有线程都结果，所以数数的线程无法执行完

public class DaemonThread3 extends Thread { public void run() { for (int i = 1; i < 1000; i++) { System.out.println("Thread i:" + i); } } public static void main(String[] args) { try { Thread t = new DaemonThread3(); t.start(); System.exit(0); } catch (Exception ex) { ex.printStackTrace(); } } }

 

一个Runable做多次Thread的运行

synchronized (str)根本没有起作用，多个线程执行的都是同一个Runable环境

public class TextThread { public static void main(String[] args) { TxtThread tt = new TxtThread(); new Thread(tt).start(); new Thread(tt).start(); new Thread(tt).start(); new Thread(tt).start(); } } class TxtThread implements Runnable { int num = 5000; String str = new String(); public void run() { while (true) { synchronized (str) { if (num > 0) { System.out.println(Thread.currentThread().getName() + "this is " + num--); } else break; } } } }

 

Volatile 变量：不保证互斥（mutual exclusion），只保证可见性（visibility）。

使用volatile变量的条件：对变量的写操作不依赖于当前值，该变量没有包含在具有其他变量的不变式中。简单说就是volatile变量的写操作和现在的变量值无关。

正确使用volatile 的模式：

（1）状态标志

利用可见性，做状态标志

（2）一次性安全发布（one-time safe publication）

防止看到不完全构造对象（只更新了引用，没有更新引用相关的内部对象），被发布的对象必须是线程安全的，或者是有效的不可变对象。

（3）独立观察（independent observation）

利用可见性，做变化频繁的变量

（4）：“volatile bean” 模式

所有内部变量都是volatile，都必须是有效不可变对象，不能包含数组（因为volatile只能限制数组引用，而不是每个数组元素），gette/setter方法不能包含任何逻辑代码

（5）开销较低的读－写锁策略

 

由于Volatile安全实施的条件较为严格，所以除非考虑效率因素，尽量不要使用Volatile模式。