BlogJava-小舒的java世界-文章分类-J2SE 学习笔记

java多线程学习总结

郑舒力 — Thu, 05 Mar 2009 12:49:00 GMT

关于 java多线程学习总结
小弟的第二篇j2se学习笔记，如果有错误或者遗漏的地方，还恳请各位高手老鸟们不要见笑，多给小弟一些批评，建议！

一、线程的基本概念
简单的说：线程就是一个程序里不同的执行路径
在同一个时间点上cpu只会有一个线程在执行
Java里的多线程是通过java.lang.Thread类来实现的
每个线程都拥有自己独立的方法栈空间

二、java线程的创建和启动
第一种
定义线程类实现Runnable接口
Thread myThread = new Thread(target) //target为Runnable接口类型
Runnable中只有一个方法：
public void run();用以定义线程运行体
第二种
可以定义一个Thread的子类并重写其run方法：
  clas MyThread extends Thread{
   public void run(){}
  }
线程类必须通过执行Thread的start()方法启动一个新的线程
如果调用run()方法是属于方法的调用，不会启动一个新的线程
推荐使用第一种方式创建线程，使用接口较为灵活

二、线程状态装换
调用线程start()方法时，线程进入就绪状态，Cpu分配时间片，线程进入运行状态
时间片结束，run()方法未执行完，线程进入阻塞状态。

三、线程控制基本方法
isAlive() //判断线程是否还“活着”，即线程是否还未终止
getPriority() //获得线程的优先级数值
setPriority() //设置线程的优先级指数
Thread.sleep() //静态方法，将当前线程睡眠指定毫秒数
join()  //调用某线程的该方法，将当前线程与该线程合并，
   //即等待该线程结束，再回复当前线程的运行。
yield()  //让出CPU，当前线程进入就绪状态等待调度
interrupt() //中断线程
wait()  //当前线程进入对象的wait pool
notify()/all //唤醒对象的wait pool中的一个/所有等待线程

四、sleep方法
Thread的静态方法
public static void sleep(long millis)throws InterruptedException
必须对异常进行捕捉
Thread.currentThread(); //拿到当前线程

五、interrupt方法一种让线程退出的方式。

import java.util.*;
public class TestInterrupt{
    public static void main(String[] args){
        MyThread t = new MyThread();
        t.start();
        try{Thread.sleep(10000);}
        catch(InterruptedException i){}
        t.interrupt();
    }
}

class MyThread extends Thread{
    public void run(){
        while(true){
            try{
                System.out.println("------"+new Date()+"-----");
                Thread.sleep(1000);
            }catch(InterruptedException i){
                return;
            }
        }
    }
}

六、join和yield方法
t.join(); //t的run()方法完才会继续执行当前线程方法体
//也就是两个线程变成了一个线程
t.yield(); //暂停当前正在执行的线程对象，并执行其他线程。方法为静态
//哪个线程体执行此方法，哪个线程让步

public class TestYield {
  public static void main(String[] args) {
    MyThread3 t1 = new MyThread3("t1");
    MyThread3 t2 = new MyThread3("t2");
    t1.start(); t2.start();
  }
}
class MyThread3 extends Thread {
  MyThread3(String s){super(s);}
  public void run(){
    for(int i =1;i<=100;i++){
      System.out.println(getName()+": "+i);
      if(i%10==0){
        yield();
      }
    }
  }
}

七、线程优先级别
线程的优先级用数字表示，范围从1到10，一个线程的缺省优先级为5.
Thread.MAX_PRIORITY=1
Thread.MIN_PRIORITY=10
Thread.NORM_PRIORITY=5
例：t.setPriority(Thread.NORM_PRIORITY+3);

★八、线程同步
1.同步代码块
synchronized(this){ //在执行代码块过程中，不会被其他线程打断
...
}
public sunchronized void method //执行此方法时，当前对象被锁定
在Java语言中，引入了对象互斥锁的概念，保证共享数据操作的完整性，每个对象都对应一个可称为"互斥锁"的标记，这个标记保证在任一时刻，只能有一个线程访问该对象。
2.线程死锁

public class TestDeadLock implements Runnable {
    public int flag = 1;
    static Object o1 = new Object(), o2 = new Object();
    public void run() {
System.out.println("flag=" + flag);
        if(flag == 1) {
            synchronized(o1) {
                try {
                    Thread.sleep(500);
                } catch (Exception e) {
                    e.printStackTrace();
                }
                synchronized(o2) {
                    System.out.println("1");
                }
            }
        }
        if(flag == 0) {
            synchronized(o2) {
                try {
                    Thread.sleep(500);
                } catch (Exception e) {
                    e.printStackTrace();
                }
                synchronized(o1) {
                    System.out.println("0");
                }
            }
        }
    }

    public static void main(String[] args) {
        TestDeadLock td1 = new TestDeadLock();
        TestDeadLock td2 = new TestDeadLock();
        td1.flag = 1;
        td2.flag = 0;
        Thread t1 = new Thread(td1);
        Thread t2 = new Thread(td2);
        t1.start();
        t2.start();

    }
}

九、生产者消费者问题

public class ProducerConsumer {
    public static void main(String[] args) {
        SyncStack ss = new SyncStack();
        Producer p = new Producer(ss);
        Consumer c = new Consumer(ss);
        new Thread(p).start();
        new Thread(p).start();
        new Thread(p).start();
        new Thread(c).start();
    }
}

class WoTou {
    int id;
    WoTou(int id) {
        this.id = id;
    }
    public String toString() {
        return "WoTou : " + id;
    }
}

class SyncStack {        //栈实现
    int index = 0;
    WoTou[] arrWT = new WoTou[6];    //相当于装物品的篮子

    public synchronized void push(WoTou wt) {    //生产物品，线程安全
        while(index == arrWT.length) {        //当篮子满了线程等待
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

        }
        this.notifyAll();    //开始生产时，叫醒等待的其他线程开始消费
        arrWT[index] = wt;
        index ++;
    }

    public synchronized WoTou pop() {        //消费物品，线程安全
        while(index == 0) {            //如果篮子空了
            try {
                this.wait();        //线程等待,等待生产者开始                            //生产，叫醒此线程
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

        }
        this.notifyAll();            //消费时喊醒生产者生产
        index--;
        return arrWT[index];
    }
}

class Producer implements Runnable {            //生产者类
    SyncStack ss = null;
    Producer(SyncStack ss) {
        this.ss = ss;
    }

    public void run() {
        for(int i=0; i<20; i++) {    //生产20个
            WoTou wt = new WoTou(i);
            ss.push(wt);
            System.out.println("生产了：" + wt);
            try {
                Thread.sleep((int)(Math.random() * 200));
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

class Consumer implements Runnable {
    SyncStack ss = null;
    Consumer(SyncStack ss) {
        this.ss = ss;
    }

    public void run() {
        for(int i=0; i<20; i++) {        //消费20个
            WoTou wt = ss.pop();
            System.out.println("消费了: " + wt);
            try {
                Thread.sleep((int)(Math.random() * 1000));
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

郑舒力 2009-03-05 20:49 发表评论

J2SE IO流API学习笔记

郑舒力 — Tue, 03 Mar 2009 02:21:00 GMT

关于java IO流学习总结

一、IO流的三种分类方式
    1.按流的方向分为：输入流和输出流
    2.按流的数据单位不同分为：字节流和字符流
    3.按流的功能不同分为：节点流和处理流
二、IO流的四大抽象类：
字符流：Reader Writer
字节流：InputStream(读数据)
  OutputStream(写数据)
三、InputStream的基本方法
int read() throws IOException 读取一个字节以整数形式返回，如果返回-1已到输入流的末尾
void close() throws IOException 关闭流释放内存资源
long skip(long n) throws IOException 跳过n个字节不读

四、OutputStream的基本方法
void write(int b) throws IOException 向输出流写入一个字节数据
void flush() throws IOException 将输出流中缓冲的数据全部写出到目的地
五、Writer的基本方法
void write(int c) throws IOException 向输出流写入一个字符数据
void write(String str) throws IOException
将一个字符串中的字符写入到输出流
void write(String str,int offset,int length)
将一个字符串从offset开始的length个字符写入到输出流
void flush() throws IOException 将输出流中缓冲的数据全部写出到目的地
六、Reader的基本方法
int read() throws IOException 读取一个字符以整数形式返回，如果返回-1已到输入流的末尾

七、节点流类型

八、访问文件之FileInputStream和FileOutputStream继承基类用于向文件中输入输出字节

九、访问文件之FileReader和FileWriter继承基类用于向文件中输入输出字符
----输出流在构造函数第二个参数可以设置true意义为跟在已有文件后进行输入
----此类流会抛出FileNotFoundException需要对其进行显示捕捉

十、缓冲流：缓冲流要套接在相应的节点流之上，提高了读写的效率。
此处理流的构造方法都得传相对应的基类类型

BufferedReader：提供了readLine方法用于高校读取一行字符串
BufferedWriter：提供了newLine用于写入一个行分隔符也就是换行
BufferedInputStream 没多大用处
BufferedOutputStream 没多大用处

十一、转换流：主要作用将字节流转换成字符流。用处较大！
转换流在构造时可以指定其编码集合

InputStreamReader需要和InputStream套接
OutputStreamWriter需要和OutputStream套接
例：OutputStreamWriter osw = new OutputStreamWriter (
new FileOutputStream(文件路径);
方法例：osw.getEncoding(); 获得流的编码方式

十二、数据流与字节数组流：
数据流主要为实现可以存取Java原始数据类型如long,boolean
数据流是字节流
DataInputStream需要和InputStream套接
DataOutputStream需要和OutputStream套接
DataInputStream方法:readBoolean() readInt() read...()...
readUTF()：网络传输常用方法读一个Unicode字符串
DataOutputStream方法与DataInputStream基本对应为写的方法
//此构造函数等于已可以往一个字节数组里输入内容
ByteArrayOutputStream baos = new ByteArrayOutputStream ();
//此方法为获取一个字节数组方法返回字节数组
baos.toByteArray();
//此方法获取字节数组占了多少字节
new ByteArrayInputStream(一个字节数组).available()

1ByteArrayOutputStream baos =
2                        new ByteArrayOutputStream();
3    DataOutputStream dos =
4                        new DataOutputStream(baos);
5    try {
6      dos.writeDouble(Math.random());
7      dos.writeBoolean(true);
8      ByteArrayInputStream bais =
9          new ByteArrayInputStream(baos.toByteArray());
10      System.out.println(bais.available());
11      DataInputStream dis = new DataInputStream(bais);
12      System.out.println(dis.readDouble());
13      System.out.println(dis.readBoolean());
14      dos.close();  dis.close();
15    } catch (IOException e) {
16      e.printStackTrace();
17    }

十二、Print流
Print流只有输出流无输入流,PrintWriter和PrintStream分别针对字符字节
两个类提供了重载的Print和Println方法用于多种数据类型的输出
PrintWriter和PrintStream的输出操作不会抛出异常
PrintWriter和PrintStream有自动flush功能
----System.setOut(接收OutputStream类):用于设置系统默认输出流

十二、Object流
等同于c#序列化，用直接将Object写入或读出
transient关键字为不序列化此成员变量
需要序列化的类必须实现Serializable接口
主要方法:writeObject(Object); readObject();
读出为Object类型需要强转数据类型

1 import java.io.*;
2
3 public class TestObjectIO {
4     public static void main(String args[]) throws Exception {
5         T t = new T();
6         t.k = 8;
7         FileOutputStream fos = new FileOutputStream("d:/share/java/io/testobjectio.dat");
8         ObjectOutputStream oos = new ObjectOutputStream(fos);
9         oos.writeObject(t);
10         oos.flush();
11         oos.close();
12
13         FileInputStream fis = new FileInputStream("d:/share/java/io/testobjectio.dat");
14         ObjectInputStream ois = new ObjectInputStream(fis);
15         T tReaded = (T)ois.readObject();
16         System.out.println(tReaded.i + " " + tReaded.j + " " + tReaded.d + " " + tReaded.k);
17
18     }
19 }
20
21 class T
22     implements Serializable
23 {
24     int i = 10;
25     int j = 9;
26     double d = 2.3;
27     transient int k = 15;
28 }

郑舒力 2009-03-03 10:21 发表评论