java 多线程总结-02

Runtime类

    Runtime是一个典型的单例设计模式的实例（饿汉子）

    使用：     

        Runtime r = Runtime.getRuntime();
        //r.exec("shutdown -s -t 300"); //300秒后关机
        r.exec("shutdown -a"); //取消关机

    实例:

               

public class TestRunTime {
    public static void main(String[] args) throws IOException {
        Runtime runtime = Runtime.getRuntime();
        //Process ipconfig = runtime.exec("ipconfig");
        Process ipconfig = runtime.exec("ping www.baidu.com");
        InputStream inputStream = ipconfig.getInputStream();

        BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(ipconfig.getInputStream(),"gbk"));
        String readLine ;
        while ( (readLine = bufferedReader.readLine()) != null ){
            System.out.println(readLine);
        }
    }
}

Timer类

方法：

 void cancel() 终止此计时器，丢弃所有当前已安排的任务。 
 int purge() 从此计时器的任务队列中移除所有已取消的任务。 
 void schedule(TimerTask task, Date time) 安排在指定的时间执行指定的任务。 
 void schedule(TimerTask task, Date firstTime, long period) 安排指定的任务在指定的时间开始进行重复的固定延迟执行。 
 void schedule(TimerTask task, long delay) 安排在指定延迟后执行指定的任务。 
 void schedule(TimerTask task, long delay, long period) 安排指定的任务从指定的延迟后开始进行重复的固定延迟执行。 
 void scheduleAtFixedRate(TimerTask task, Date firstTime, long period) 安排指定的任务在指定的时间开始进行重复的固定速率执行。 
 void scheduleAtFixedRate(TimerTask task, long delay, long period) 安排指定的任务在指定的延迟后开始进行重复的固定速率执行。 

实例：

MyTask类：

package com.th.thread;

import java.util.TimerTask;

/**
 * Created by Administrator on 2018/6/8.
 */
public class MyTask extends TimerTask {
    private String taskName ;

    public MyTask(String taskName) {
        this.taskName = taskName;
    }

    @Override
    public void run() {
        System.out.println("Start My Task is : " + taskName);
        try {
            Thread.sleep(5*1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("End My Task is : " + taskName);
    }
}

TestTimer类：

package com.th.thread;

import java.util.Date;
import java.util.Timer;

/**
 * Created by Administrator on 2018/6/8.
 *
 * Timer类
 */
public class TestTimer {
    public static void main(String[] args) throws InterruptedException {

        System.out.println("开始测试Timer中的方法: ");
        Timer timer = new Timer();
        //testSchedule(timer);

        //testScheduleFirstTimePeriod(timer);

        //testScheduleDelay(timer);

        //testScheduleDelayPeriod(timer);

        testScheduleAtFixedRate(timer);

    }

    /**
     *  跟testScheduleDelayPeriod 类似
     * @param timer
     */
    private static void testScheduleAtFixedRate(Timer timer) {
        timer.scheduleAtFixedRate(new MyTask("testScheduleAtFixedRate"),3*1000,1*1000);
    }

    /**
     * 安排指定的任务从指定的延迟后开始进行重复的固定延迟执行。以近似固定的时间间隔（由指定的周期分隔）进行后续执行。
     * @param timer
     */
    private static void testScheduleDelayPeriod(Timer timer) {
        /**
         * task - 所要安排的任务。
         * delay - 执行任务前的延迟时间，单位是毫秒。(首次执行该任务之前延迟的时间)
         * period - 执行各后续任务之间的时间间隔，单位是毫秒。（以后每次执行该任务的频率）
         */
        timer.schedule(new MyTask("testScheduleDelayPeriod"),3*1000,2*1000);
    }


    /**
     * 安排在指定延迟后执行指定的任务。
     * @param timer
     */
    private static void testScheduleDelay(Timer timer) {
        /**
         * delay 时间后开始执行这个任务
         */
        timer.schedule(new MyTask("testScheduleDelay"),3*1000);
    }

    /**
     *
     * @param timer
     */
    private static void testScheduleFirstTimePeriod(Timer timer) {
        /**
         * task - 所要安排的任务。
         * firstTime - 首次执行任务的时间。
         * period - 循环执行这个任务频率（多久执行一次）。
         * 如果该任务执行的时间超过了period时间:上次任务执行完后立马开始执行下一次任务。
         */
        timer.schedule(new MyTask("testScheduleFirstTimePeriod"),new Date(),3000);
    }

    /**
     * 安排在指定的时间执行指定的任务。如果此时间已过去，则安排立即执行该任务。
     * @param timer
     */
    private static void testSchedule(Timer timer) {
        timer.schedule(new MyTask("testSchedule"),new Date() );
    }


}

多线程通信（互斥锁）

ReentrantLock 类  Condition  类

ReentrantLock lock = new ReentrantLock();

Condition c = lock.newCondition();

c.await(); 

c.signal();

package com.th.thread;

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;

/**
 * Created by Administrator on 2018/6/8.
 */
public class Print3 {

    private ReentrantLock lock = new ReentrantLock();
    Condition c1 = lock.newCondition();
    Condition c2 = lock.newCondition();
    Condition c3 = lock.newCondition();

    private int flag = 1;
    public void print1() throws InterruptedException {
        lock.lock();
        if ( flag != 1 ) {
            c1.await();
        }
        System.out.print("一");
        System.out.print("二");
        System.out.print("三");
        System.out.print("四");
        System.out.print("五");
        System.out.print("\r\n");
        flag = 2 ;
        c2.signal();
        lock.unlock();
    }

    public void print2() throws InterruptedException {
        lock.lock();
        if ( flag !=2 ) {
            c2.await();
        }
        System.out.print("1-");
        System.out.print("2-");
        System.out.print("3-");
        System.out.print("4-");
        System.out.print("5");
        System.out.print("\r\n");

        flag = 3;
        c3.signal();
        lock.unlock();
    }


    public  void print3() throws InterruptedException {
        lock.lock();
        if ( flag !=3 ) {
            c3.await();
        }
        System.out.print("a-");
        System.out.print("b-");
        System.out.print("c-");
        System.out.print("4-");
        System.out.print("5");
        System.out.print("\r\n");

        flag = 1;
        c1.signal();
        lock.unlock();
    }

}

package com.th.thread;

/**
 * Created by Administrator on 2018/6/8.
 */
public class TestReentrantLock {
    public static void main(String[] args) {
        Print3 p = new Print3();
        new Thread(new Runnable() {
            @Override
            public void run() {
                while ( true ){
                    try {
                        p.print1();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }).start();


        new Thread(new Runnable() {
            @Override
            public void run() {
                while ( true ){
                    try {
                        p.print2();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }).start();


        new Thread(new Runnable() {
            @Override
            public void run() {
                while ( true ){
                    try {
                        p.print3();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }).start();
    }
}