Java复习篇六

从天津转站北京，爬到中关村到直立行走
Java复习篇六
Thread:运行中的的程序
进程：是一个正在执行中的程序。
  每一个进程执行都有一个执行顺序。该顺序是一个执行路径，或者叫一个控制单元。
线程：就是进程中一个独立的控制单元。
  控制着进程的执行。
Java VM启动的时候会有一个进程java.exe,该进程中至少一个线程负责java程序的执行。
而且这个线程运行的代码存在于main中，此线程称之为主线程。
扩展：其实更细节的说明了JVM，JVM启动不止一个线程，负责垃圾回收机制的线程。
多线程的一个特性：随机性
五种状态：
运行状态：即有运行资格又有执行权
临时状态：具备运行资格，但没有执行权
冻结：放弃了执行权
Sleep
线程有自己默认的名称

第二种Runnable的接口
实现方式的好处，避免了单继承的局限性。
在定义线程时，建立使用实现方式。
两种方式区别：
继承Thread：线程代码参访Thread子类run方法中。
实现Runnable:线程代码存放在接口的子类run方法。
多线程的运行出现了安全问题。

线程间的通信：
多个线程在操作同一个资源
等待唤醒机制
等待线程都存在线程池中。
Wait()
Notify() 都使用同步中，因为要是有监视器（锁）的线程安全。
notifyAll() 同步才具有锁。

多线程
进程：任务
任务并发执行是一个宏观概念，微观上是串行的。
进程的调度是有OS负责的（有的系统为独占式，有的系统为共享式，根据重要性，进程有优先级）。


线程由两种实现方式：
第一种方式：
class MyThread extends Thread{
   public void run(){
   需要进行执行的代码，如循环。
}
}

public class TestThread{
  main(){
   Thread t1=new Mythread();
   T1.start();
}
}

只有等到所有的线程全部结束之后，进程才退出。

第二种方式：
Class MyThread  implements Runnable{
  Public  void run(){
  Runnable target=new MyThread();
  Thread t3=new Thread(target);
  Thread.start();//启动线程
}
}

package com.xinglefly.java.test;

/**
* 线程间的通信:
* 多个线程在操作同一个资源。
* wait;notify(),notifyall();都是使用在同步中，因为要持有监视器（锁）的线程。因为同步才具有锁。
* 为什么这些操作线程的方法要定义Object类中呢？
* 因为这些方法在操作同步中线程时，都必须要标识它们所操作线程只有的锁。只有同一个锁上的被等待线程，可以被同一个锁上notify唤醒。
* 不可以对不同锁中的线程进行唤醒。也就是说，等待和唤醒必须是同一个锁。
* 而锁可以是任意对象，所以被任意对象调用的方法定义Object类中。
* @author xinglefly
* @version 1
*/
class Recle{
private String name;
private String sex;
private boolean flag = false;

public synchronized void set(String name,String sex){

if(flag)
try{this.wait();}catch(Exception e){e.printStackTrace();}
this.name=name;
this.sex=sex;
flag=true;
this.notify();


}
public synchronized void out(){
if(!flag)
try{this.wait();}catch(Exception e){e.printStackTrace();}
System.out.println(name+"...."+sex);
flag=false;
this.notify();
}
}

class Input implements Runnable{
private Recle r;
// Object obj = new Object();
int x=0;
public Input(Recle r){
this.r=r;
}

public void run(){
int x=0;
while(true){
if(x==0)
r.set("chan", "man");
else
r.set("lili", "femal");
x = (x+1)%2;
}
/*synchronized (r) {在内部中同步代码块
if(r.flag)
try{r.wait();}catch(Exception e){e.printStackTrace();}

if(x==0){
r.name="chan";
r.sex="man";
}else{
r.name="lili";
r.sex="femal";
}
x = (x+1)%2;
r.flag = true;
r.notify();
}*/

}
}

class Output implements Runnable{
private Recle r;
// Object obj = new Object();
public Output(Recle r) {
this.r=r;
}
public void run(){
while(true){
r.out();
/*synchronized (r) {在内部中同步代码块
if(!r.flag){
try {
r.wait();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
System.out.println(r.name+"........"+r.sex);
r.flag=false;
r.notify();
}*/
}

}
}

public class ThreadTest {
public static void main(String[] args){
Recle r = new Recle();

new Thread(new Input(r)).start();
new Thread(new Output(r)).start();

/*Recle r = new Recle();在内部中同步代码块
Input in = new Input(r);
Output out = new Output(r);

Thread t1 = new Thread(in);
Thread t2 = new Thread(out);
t1.start();
t2.start();*/

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


                  ①              ⑴
                 ②                   ⑵
                ③                        ⑶             run()结束
    Start()
                           OS分配CPU

                        CPU时间片结束
                             yield()                      o.wait()
                                            等待锁标记


                                                 notify()
注意：图中标记依次为
①输入完毕；②wake up③t1退出
⑴如等待输入（输入设备进行处理，而CUP不处理），则放入阻塞，直到输入完毕。
⑵线程休眠sleep（）
⑶t1.join()指停止main()，然后在某段时间内将t1加入运行队列，直到t1退出，main()才结束。
特别注意：①②③与⑴⑵⑶是一一对应的。

进程的休眠：Thread sleep(1000);//括号中以毫秒为单位
当main()运行完毕，即使在结束时时间片还没有用完，CPU也放弃此时间片，继续运行其他程序。
Try{Thread.sleep(1000);}
Catch(Exception e){e.printStackTrace(e);}
T1.join()表示运行线程放弃执行权，进入阻塞状态。
当t1结束时，main()可以重新进入运行状态。
T1.join实际上是把并发的线程编程并行运行。
线程的优先级：1-10，越大优先级越高，优先级越高被OS选中的可能性就越大。（不建议使用，因为不同操作系统的优先级并不相同，使得程序不具备跨平台性，这种优先级只是粗略地划分）。
注：程序的跨平台性：除了能够运行，还必须保证运行的结果。

一个使用yield()就马上交出执行权，回到可运行状态，等待OS的再次调用。
package com.xinglefly.java.test;

/**
*
* @author xinglefly
*
*/
public class ThreadTest1 {
public static void main(String[] args){
Cycle cy = new Cycle();
Produce in = new Produce(cy);
Consume out = new Consume(cy);

Thread t1 = new Thread(in);
Thread t2 = new Thread(in);
Thread t3 = new Thread(out);
Thread t4 = new Thread(out);

t1.start();
t2.start();
t3.start();
t4.start();

}
}

class Cycle{
private String name;
private int count=1;
private boolean flag = false;

public synchronized void set(String name){
while(flag)//if判断一次，while判断多次
try{
this.wait();
}catch(Exception e){
e.printStackTrace();
}
this.name = name+"--"+count++;
System.out.println(Thread.currentThread().getName()+"--生产者...."+this.name);
flag=true;
// notify()唤醒本方
// notifyall()全部唤醒
this.notifyAll();
}

public synchronized void out(){
while(!flag)
try{
this.wait();
}catch(Exception e){
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+"--消费者........"+this.name);
flag=false;
this.notifyAll();
}
}

class Produce implements Runnable{
private Cycle cy;
// int x=0;
public Produce(Cycle cy){
this.cy=cy;
}
public void run(){
while(true){
cy.set("+商品+");
}
}
}
class Consume implements Runnable{
private Cycle cy;
public Consume(Cycle cy){
this.cy = cy;
}
public void run(){
while(true){
cy.out();
}
}
}


程序员需要关注的线程同步和互斥的问题。
多线程的并发一般不是程序员决定，而是由容器决定。
多线程出现故障的原因：
两个线程同时访问一个数据资源（临界资源），形成数据发生不一致和不完整。
数据的不一致往往是因为一个线程中的两个关联的操作只完成了一步。

避免以上的问题可采用对数据进行加锁的方法
每个对象除了属性和方法，都有一个monitor（互斥锁标记），用来将这个对象交给一个线程，只有拿到monitor的线程才能够访问这个对象。
Synchronized:这个修饰词可以用来修饰方法和代码块

Synchronized用来修饰方法，表示当某个线程调用这个方法之后，其他的事件不能再调用这个方法。只有拿到obj标记的线程才能够执行代码块。
注意：Synchronized一定使用在一个方法中。
锁标记是对象的概念，加锁是对对象加锁，目的是在线程之间进行协调。

当用Synchronized修饰某个方法的时候，表示该方法都对当前对象加锁。
给方法加Synchronized和用Synchronized修饰对象的效果是一致的。

一个线程可以拿到多个锁标记，一个对象最多只能将monitor给一个线程。
Synchronized是以牺牲程序运行的效率为代价的，因此应该尽量控制互斥代码块的范围。

方法的Synchronized特性本身不会被继承，只能覆盖。
线程因为未拿到锁标记而发生的阻塞不同于前面五个基本状态中的阻塞，称为锁池。
每个对象都有自己的一个锁池的空间，用于放置等待运行的线程。
这些线程中哪个线程拿到锁标记由系统决定。

锁标记如果过多，就会出现线程等待其他线程释放锁标记，而又都不释放自己的锁标记供其他线程运行的状况。就是死锁。
死锁的问题通过线程间的通信的方式进行解决。
线程间通信机制实际上也就是协调机制。
线程间通信使用的空间称之为对象的等待队列，则个队列也是属于对象的空间的。
Object类中又一个wait()，在运行状态中，线程调用wait()，此时表示着线程将释放自己所有的锁标记，同时进入这个对象的等待队列。
等待队列的状态也是阻塞状态，只不过线程释放自己的锁标记。
Notify()
如果一个线程调用对象的notify()，就是通知对象等待队列的一个线程出列。进入锁池。如果使用notifyall()则通知等待队列中所有的线程出列。

注意：只能对加锁的资源进行wait()和notify()。

释放锁标记只有在Synchronized代码结束或者调用wait()。
注意锁标记是自己不会自动释放，必须有通知。
注意在程序中判定一个条件是否成立时要注意使用WHILE要比使用IF要严密。
WHILE会放置程序饶过判断条件而造成越界。
补充知识：
suspend（）是将一个运行时状态进入阻塞状态（注意不释放锁标记）。恢复状态的时候用resume()。Stop()指释放全部。
这几个方法上都有Deprecated标志，说明这个方法不推荐使用。

一般来说，主方法main()结束的时候线程结束，可是也可能出现需要中断线程的情况。对于多线程一般每个线程都是一个循环，如果中断线程我们必须想办法使其退出。
如果主方法main()想结束阻塞中的线程（比如sleep或wait）
那么我们可以从其他进程对线程对象调用interrupt()。用于对阻塞（或锁池）会抛出例外Interrupted Exception。
这个例外会使线程中断并执行catch中代码。

多线程中的重点：实现多线程的两种方式，Synchronized,以及生产者和消费者问题

练习：
存车位的停开车的次序输出问题；
写两个线程，一个线程打印1-52，另一个线程答应字母A-Z。打印顺序为12A34B56C……5152Z。通过使用线程之间的通信协调关系。
注：分别给两个对象构造一个对象o，数字每打印两个或字母每打印一个就执行o.wait()。在o.wait()之前不要忘了写o.notify()。
package com.blackhorse.xinglefly;

import java.util.ArrayList;

/**
* 写两个线程，一个线程打印1-52，另一个线程答应字母A-Z。打印顺序为12A34B56C……5152Z。通过使用线程之间的通信协调关系
* 注：分别给两个对象构造一个对象o，数字每打印两个或字母每打印一个就执行o.wait()。在o.wait()之前不要忘了写o.notify()。
* @author xinglefly
* @version 1
*/
public class Thread4 {
public static void main(String[] args)throws Exception{
//随机产生26个字母的表示方法
String chars = "abcdefghijklmnopqrstuvwxyz";
// System.out.println(chars.charAt((int)(Math.random()*26)));
ArrayList list = new ArrayList();
for(char c='a';c<='z';c++){
list.add(c);
}
String str = "";
for(int i=0;i<26;i++){
int num = (int)(Math.random()*26);
str = str+list.get(num);
}
System.out.println(str);

//------------------------------------
Object obj = new Object();
ThreadTest1 t1 = new ThreadTest1(obj);
ThreadTest2 t2 = new ThreadTest2(obj);
t1.start();
t2.start();
}
}
//线程打印1-52
class ThreadTest1 extends Thread{
private Object obj;
public ThreadTest1(Object obj){
this.obj=obj;
}
public void run(){
synchronized(obj){
for(int i=1;i<53;i++){
System.out.print(i+" ");
if(i%2==0){
//唤醒其他线程
obj.notifyAll();
try{
obj.wait();
}catch(InterruptedException e){
e.printStackTrace();
}
}
}
}
}
}
//线程打印字母
class ThreadTest2 extends Thread{
private Object obj;
public ThreadTest2(Object obj){
this.obj=obj;
}
public void run(){
synchronized(obj){
for(int i=0;i<26;i++){
System.out.print((char)('A'+i)+"");
//唤醒其它线程
obj.notifyAll();
try{
if(i!=25){
obj.wait();
}
}catch(InterruptedException e){
e.printStackTrace();
}
}
}
}
}
补充说明：通过Synchronized，可知Vector较ArrayList方法的区别就是Vector所有的方法都有Synchronized。所以Vector更为安全。
同样：Hashtable较HashMap也是如此。

package com.xinglefly.java.test;

/**
* 简单的买票程序，多个窗口同时买票
* @author xinglefly
* @version 1
*/

/**
* 第二种方法，实现接口Runnable
* 实现方式的好处：避免了单继承的局限性。
* 在定义线程时，建立使用实现方式。
*
* 两种方式的区别：继承Thread：线程代码存放Thread子类run方法中。
* 实现Runnable:线程代码存在在接口的子类run方法中。
*
* 多线程的运行出现了安全问题：原因
* 当多条语句在操作同一个线程共享数据时，一个线程只对多个线程执行一部分，还没有执行完。
* 另一个线程参与进来执行，导致共享数据的错误。
*
* 解决办法：只能让一个线程执行完，在执行过程中，其他线程不可以参与执行。
*
* 专业的解决方式：同步代码块。
*/
class Tick implements Runnable{//extends Thread{
private static int ticks=100;
boolean flag = true;
public void run(){
// Object obj = new Object();
/**
* synchronized 锁旗标
* 对象如同锁，持有锁的线程可以在同步中执行，没有持有锁的线程即使获取cpu的执行权，也进不去，因为没有获取锁。
* 同步的前提：
* 1）必须有两个或两个以上的线程
* 2)必须是多个线程使用同一个锁
*
* 好处： 解决多线程的安全问题。
* 弊端： 多个线程需要判断锁，较为消耗资源。
*/

if(flag){
while(true){
// synchronized (obj) {//同步函数用的是obj，所以不是同一个对象
// synchronized (this){//所以同步函数使用的锁是this
synchronized (Tick.class){//静态同步方法，使用的锁应该是该方法所在类的字节码文件对象，类名.calss
if(ticks>0){
try{Thread.sleep(10);}catch(Exception e){
e.printStackTrace();
System.out.println(Thread.currentThread().getName()+"-code "+ticks--);
}
}
}
}
}else
while(true)
show();
}
/**
* 同步函数用的是哪一个锁？
* 函数需要被对象调用，那么函数都有一个所属对象引用就是this
*所以同步函数中使用的锁是this
*/
// public synchronized void show(){//this
public static synchronized void show(){//同步函数静态修饰后，通过验证不是this,静态内存中，内存中没有本类对象，但一定有该类对应的字节码文件对象
if(ticks>0){
try{Thread.sleep(10);}catch(Exception e){
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+"----show..."+ticks--);
}
}
}
public class ThredTest {
public static void main(String [] args){
//第一种创建方式
/*Tick t1 = new Tick();
Tick t2 = new Tick();

t1.start();
t2.start();
*/
//第二种创建方式是实现Runnable接口
Tick t = new Tick();
Thread t1 = new Thread(t);
Thread t2 = new Thread(t);
t1.start();//处于临时状态，持有权
try{Thread.sleep(10);}catch(Exception e){
e.printStackTrace();
}
t.flag=false;
t2.start();
}
}


对比：
什么是进程
进程就是应用程序的执行实例
进程的特征： 动态性  并发性  独立性
什么是线程
进程每部的一个执行单元，他是程序中的一个单一的顺序流程
线程的特点：
1、一个进程可以有多个线程，而一个线程至少要有一个父进程
2、线程可以有自己的堆栈、数据计数器和局部变量、
3、线程与父进程的其他线程共享进程的所有资源
4、独立运行，采用抢占的方式
5、一个线程可以创建和删除另外一个线程
6,、同一个进程中多个线程之间可以并发执行
7、线程的调度管理是有进程来完成的
线程的分类
1、系统级线程    2,、用户级线程
多线程开发的优势;
1、 能改善用户体验
2、 提高资源的利用率
线程使用的步骤：
1、 定义一个线程
2、 创建一个线程的实例
3、 启动线程
4、 终止线程
所有线程都是java.lang.Thread类或者其子类的实例
Thread类定义线程：
1、 定义thread的子类  重写父类的run方法
2、 创建thread子类的对象、
3、 调用子类对象的start（）方法启动线程
Runnabie  接口定义线程
1、 定义Runnadle 接口的实现类
2、 用 new Thread(Runnadie) 的方式创建一个线程
3、 start（）方法启动线程
Thread创建线程的优缺：有点：1 编写降低 2可以使用this关键字直接访问当前线程 缺点：无法继承其他类
Runnable：有点 可以继承其他类  多个线程之间可以使用同一个Runnable对象 缺点：编程方式稍微复杂 如需访问当前线程，则需要用thread类的currentThread（）方法来引用当前线程
线程的优先级：
1、 默认情况下，一个线程继承其父类的类的优先级
2、 优先级表示为一个整数值
3、 优先级越高，执行的机会越大，反之执行的机会越小
4、 优先级的线程可以抢占低优先级的线程CPU资源
设置线程的优先级
线程对象.setPriority(优先级的值) 注意;优先级的取值范围1-10 默认为5