CoreJava学习笔记11

Java多线程编程

进程，即运行中的程序，多任务操作系统中并发的一个任务（CPU是分时间片执行多个进程的），线程，其本质是进程中顺序的执行流程，进程有独立的进程空间进程中的数据存放空间（对空间和栈空间）是独立的。线程没有独立的存放数据的空间，数据存储空间（堆空间）是共享的，线程间的栈空间是独立的，线程消耗的资源比进程小。

线程，是进程（运行中的程序）中顺序的执行流程，进程可以划分出多个线程。

JVM（java虚拟机）本身就是一个进程，java只能够申请创建线程。

操作系统决定线程是否有优先级，独占式的操作系统中系统会有优先级的概念，共享式的操作系统则不会优先级的。

Java中的线程也是对象，线程类是Thread类，线程是操作系统创建并进行维护的资源，线程对象表示一个线程，本身不是线程。通过线程对象来申请创建，中止线程，访问底层的线程资源。

线程包含了三部分，cpu资源，代码，数据存储空间。

线程对象调用start()方法，线程对象就会向操作系统申请线程启动，除了申请的线程，还有main方法的线程，也就是主线程。

注意：只有运行状态的线程才有机会执行代码，主线程的中止不会影响其他的正在运行中的线程，朱线程中止也就是main()方法退出了。只有进程中的所有线程都中止时，进程（JVM进程）才会退出，只要有线程没有中止，进程就不会退出。

线程编程的两种方法
1， 写一个类，继承Thread类，覆盖Thread类中继承来的run()方法，这样就写好了自定义的线程类。
例：

public class Test{
public static void main(String[] args){
Thread t=new A();
t.start();
}
class A extends Thread{
	public void run(){
		...
	}
}

2，写一个类，实现Runable接口，实现其中的run()方法。这种方法写好的类的对象需要作为线程类创建对象时构造方法的参数。
例：

public class Test{
public static void main(String[] args){
Runable r=new b();//目标对象
Thread t=new Thread(r);//用目标对象构造线程对象
t.start();
}

class b implements Runable{
	public void run(){
		...
	}
}

Thread类的方法

public static void sleep(long millis)
                  throws InterruptedException
括号中以毫秒为单位, 使线程停止一段时间，间隔期满后，线程不一定立即恢复执行。
当main()运行完毕，即使在结束时时间片还没有用完，CPU也放弃此时间片，继续运行其他程序。
try{
Thread.sleep(1000);
}catch(InterruptedException e){
e.printStackTrace(e);
}

public final void join() throws InterruptedException
表示其他运行线程放弃执行权，进入阻塞状态，直到调用线程结束。
实际上是把并发的线程变为串行运行。

线程的优先级：1-10，越大优先级越高，优先级越高被OS选中的可能性就越大。（不建议使用，因为不同操作系统的优先级并不相同，使得程序不具备跨平台性，这种优先级只是粗略地划分）。
注：程序的跨平台性：除了能够运行，还必须保证运行的结果。

Public static void field()
使当前线程马上交出执行权，回到可运行状态，等待OS的再次调用。

Public final Boolean isActive()
验证当前线程是否是活动的，不管它是否正在运行。

线程的生命周期

下面为线程中的7中非常重要的状态：（有的书上也只有认为前五种状态：而将“锁池”和“等待池”都看成是“阻塞”状态的特殊情况：这种认识也是正确的，但是将“锁池”和“等待池”单独分离出来有利于对程序的理解）

1, 初始状态，线程创建，线程对象调用start()方法。
2，可运行状态，也就是等待Cpu资源，等待运行的状态。
3，运行状态，获得了Cpu资源，正在运行状态。
4，阻塞状态，也就是让出Cpu资源，进入一种等待状态，而且不是可运行状态，有三种情况会进入阻塞状态。
1)如等待输入（输入设备进行处理，而CPU不处理），则放入阻塞，直到输入完毕，阻塞结束后会进入可运行状态。
2)线程休眠，线程对象调用sleep()方法，阻塞结束后会进入可运行状态。
3)线程对象2调用线程对象1的join()方法，那么线程对象2进入阻塞状态，直到线程对象1中止。
5，中止状态，线程执行结束。所有线程都进入中止状态Java虚拟机进程才结束。
6，锁池状态
7，等待队列

共享数据的并发处理

多线程同时并发访问的资源叫做临界资源。

多个线程同时访问对象并要求操作相同资源时分割了原子操作就会出现问题。（原子操作，不可再分的操作）会出现数据的不一致或数据不完整，为避免这种现象采用对访问的线程做限制的方法。
Synchronized关键字

1．Synchronized修饰代码块（同步代码块），
 

 public void push(char c){ 
        synchronized(this)//只有持有当前对象的锁标记才能访问这个代码块
	{
       		 ... 
        } 
   }

对括号内的对象加锁，只有拿到锁标记的对象才能执行该代码块
2．Synchronized修饰方法
 

 public synchronized void push(char c) { 
      ... 
      } 

对当前对象的加锁，只有拿到锁标记的对象才能执行该方法。

互斥锁机制，利用每个对象都有一个monitor(锁标记)，当线程拥有这个锁标记时才能访问加了同步的这个资源，没有锁标记便进入锁池。任何一个对象系统都会为其创建一个互斥锁，这个锁是为了分配给线程的，防止打断原子操作。每个对象的锁只能分配给一个线程。

注意：构造方法不能Synchronized修饰，静态方法可以用Synchronized修饰（是对类对象加锁，类对象会在反射时讲到）。抽象方法不能用Synchronized修饰，不影响子类覆盖，子类在覆盖这个方法是可以加Synchronized，也可以不加Synchronized，所以根据Java不允许写废代码的特点是不能写在一起。

注意：对当前对象加锁，一个代码块或者方法是同步的(Synchronized)，当前对象的锁标记没有分配出去时，这个对象的锁标记为分配时，线程来访问这个代码块，会得到这个对象的锁标记，直到这个线程结束才会释放着个锁标记，其他访问这个代码块或者是方法线程就会进入这个对象锁池，没有得到当前对象的锁标记，不能访问这个代码块或者方法。当一个线程想要获得某个对象锁标记而进入锁池，这个线程又持有其他对象的锁标记，这个线程也不会释放其持有的锁标记。

注：方法的Synchronized特性本身不会被继承。
线程因为未拿到锁标记而发生阻塞进入锁池（lock pool）。每个对象都有自己的一个锁池的空间，用于放置等待运行的线程。由系统决定哪个线程拿到锁标记并运行。

使用互斥锁的注意事项

举例：男孩和女孩例子，每个女孩是一个对象，每个男孩是个线程。每个女孩都有自己的锁池。每个男孩可能在锁池里等待。

class Girl{
	public void hand(){

	}
	public syncronized void kiss(){

	}
}
class Boy extends Thread{
	public void run(){
		
	}
}

注意：只读不用加同步，只写也不用加同步，只有读写操作兼而有之时才加同步。

注意：在java.io包中Vector 和 HashTable 之所以是线程安全的，是因为每个方法都有synchronized修饰。Static 方法可以加 synchronized , 锁的是类对象。但是Vector 是 jdk 1.0 的  ArrayList 是 jdk1.2 所以实际应用还是使用ArrayList。

注意：内同步，外同步，内同步，即，类内的方法加同步(synchronized)修饰,外同步即，在需要控制只能由一个线程进行访问时，把需要控制的方法写在同步代码块里。