java复习并发

java复习二

想复习一下Java并发，看 Java 特种兵 并发部分 感觉讲的不错，写一下读书笔记

两个使用线程的方法

实现Runnable接口的多线程

package myList;

public class threadtest {
public static void main(String[] args) {
ThreadTests ds1 = new ThreadTests("阿三");
ThreadTests ds2 = new ThreadTests("李四");

Thread t1 = new Thread(ds1);

Thread t2 = new Thread(ds2);

t1.start();
t2.start();
}
}

class ThreadTests implements Runnable {
private String name;

public ThreadTests(String name) {
this.name = name;
}

public void run() {
for (int i = 0; i < 5; i++) {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(name + ": " + i);
}
}
}

//李四: 0
阿三: 0
李四: 1
阿三: 1
阿三: 2
李四: 2
李四: 3
阿三: 3
阿三: 4
李四: 4

2.扩展Thread类实现的多线程

package myList;

public class TestThread extends Thread {
public TestThread(String name) {
super(name);
}

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

public static void main(String[] args) {
Thread t1 = new TestThread("阿三");
Thread t2 = new TestThread("李四");
t1.start();
t2.start();
}
}

//李四 :0
阿三 :0
李四 :1
阿三 :1
阿三 :2
李四 :2
阿三 :3
李四 :3
阿三 :4
李四 :4

new Thread()操作没有完成对线程的创建，只有当调用start()方法时才会真正在系统中存在一个线程，Thread本身对应的实例只是JVM内一个普通Java对象，是一个线程操作的外壳，而不是真正的线程。

线程状态

1.NEW 状态

表示线程还没有启动，只是创建了一个Java外壳，要注意的是调用了start()方法不表示状态就立即改变。

2.RUNNABLE 状态

程序运行状态，任务也有可能处于等待状态

3.BLOCKED 状态

BLOCKED称为阻塞状态，原因通常是它在等待一个锁

4.WAITING 状态

通常是指一个线程拥有对象锁后进入到相应的代码区域后，调用相应的锁对象的wait()方法操作后产生的一种结果，与BLOCKED状态比较，BOLOCKED状态是虚拟机认为程序还不能进入某个区域，发生wait()操作的条件就是要进入临界区，只是还有一些其他配合的资源没有准备充分，所有产生了等待。

notify()方法是唤醒一个处于WAITING状态的线程

5.TIMED_WAITING 状态

Thread.sleep()就可以进入TIMED_WAITING状态

6.TERMINATED 状态

线程结束时的状态，run()方法执行完成

wait()与notify()

它们都使用synchronized，它们的实现是基于对象，

interrupt()

interrupt()操作在线程处于BLOCKEN, RUNNING状态没有作用，只对WAITING, TIME_WAITING状态的线程有用，让它们产生异常

还可以通过isInterrupt()判断线程是否已经被调用过中断方法

stop()与interrupt()

interrupt()是相对缓和的处理方式，stop()对处于RUNNING状态的任务会导致任务直接抛出java.lang.ThreadDeath的Error，会有一定的风险。

线程优先级

Java提供了1-10个优先级，理论上数字越大优先级越高

可以通过setPriority()来设置优先级

在JVM中还有一种特殊的后台线程，可以通过setDaemon(boolean)设置是否为后台线程，它通常优先级很低，JVM的GC线程就是后台线程，后台线程有一种很重要的的特征，如果JVM进程中活着的线程只有后台线程，就要结束整个进程。

线程合并(Join)

package myList;

class ThreadTesterA implements Runnable {

private int counter;

@Override
public void run() {
while (counter <= 10) {
System.out.print("Counter = " + counter + " ");
counter++;
}
System.out.println();
}
}

class ThreadTesterB implements Runnable {

private int i;

@Override
public void run() {
while (i <= 10) {
System.out.print("i = " + i + " ");
i++;
}
System.out.println();
}
}

public class ThreadTester {
public static void main(String[] args) throws InterruptedException {
Thread t1 = new Thread(new ThreadTesterA());
Thread t2 = new Thread(new ThreadTesterB());
t1.start();
t1.join(); // wait t1 to be finished
t2.start();
t2.join(); // in this program, this may be removed
}
}

//i = 0 Counter = 0 Counter = 1 i = 1 Counter = 2 i = 2 Counter = 3 i = 3 Counter = 4 Counter = 5 Counter = 6 Counter = 7 Counter = 8 Counter = 9 Counter = 10
i = 4 i = 5 i = 6 i = 7 i = 8 i = 9 i = 10

可以实现同步的作用

线程安全

一致性问题一般出现在多核机器上

package myList;

public class ThreadTest extends Thread{

private boolean ready;

private int number;

public void run(){
while(!ready){
number++;
}
System.out.println(ready);
}

public void readyOn(){
this.ready = true;
}

public static void main(String [] args){
ThreadTest readThread = new ThreadTest();
readThread.start();
try {
Thread.sleep(200);
} catch (InterruptedException e) {
e.printStackTrace();
}
readThread.readyOn();
System.out.println(readThread.ready);

}
}

代码可能会不能停止，因为不同变量的修改不需要立即写回到主存，而线程读取也不需要每一次去读取数据。

解决方法:1.在循环中添加一个Thread.yield()，操作就可以让线程让步CPU，进而很可能到主存中读取最新的ready的值。2.在循环中加一条System.out语句，或者将ready变量增加一个volatile修饰符也可以达到退出的目的。

ThreadLocal

ThreadLocal可以放一个线程级别的变量，但它本身可以被多个线程共享使用，而又达到线程安全的目的，且绝对线程安全。

public final static ThreadLocal<String> RESOURCE = new ThreadLocal<String>();

RESOURCE代表一个可以存放String类型的ThreadLocal对象，任何一个线程可以并发访问这个变量，对它进行写入，读取操作，都是线程安全的

原子性和锁

synchronized

synchronized通过在对象上加锁后进入临界区达到临界区串行访问的目的

1.普通方法前面加synchronized

synchronized public void test() {}

锁住了类的对象

2. 静态方法前面加synchronized

synchronized public static void test() {}

锁住了当前类

3. 代码块加锁

synchronized(object){
//代码
}

锁住的不是代码而是object对象