JavaSE 多线程（2）

死锁

多线程同步的时候, 如果同步代码嵌套, 使用相同锁, 就有可能出现死锁.
为了避免死锁出现，最好不要同步代码块嵌套。
例子
饭桌上每个人都只有一边筷子，都在旁别的人把筷子借给自己吃饭

public class Demo5_DeadLock {

    /**
     * @param args
     */
    private static String s1 = "筷子左";
    private static String s2 = "筷子右";

    public static void main(String[] args) {
        new Thread() {
            public void run() {
                while(true) {
                    synchronized(s1) {
                        System.out.println(getName() + "...获取" + s1 + "等待" + s2);
                        synchronized(s2) {
                            System.out.println(getName() + "...拿到" + s2 + "开吃");
                        }
                    }
                }
            }
        }.start();

        new Thread() {
            public void run() {
                while(true) {
                    synchronized(s2) {
                        System.out.println(getName() + "...获取" + s2 + "等待" + s1);
                        synchronized(s1) {
                            System.out.println(getName() + "...拿到" + s1 + "开吃");
                        }
                    }
                }
            }
        }.start();
    }
}

---

单例设计模式

单例设计模式：保证类在内存中只有一个对象。

如何保证类在内存中只有一个对象呢？
(1)控制类的创建，不让其他类来创建本类的对象。private
(2)在本类中定义一个本类的对象。Singleton s;
(3)提供公共的访问方式。 public static Singleton getInstance(){return s}

单例的两种写法：
（1）饿汉式 开发用这种方式

//饿汉式
class Singleton {
    //1,私有构造函数，其他类就不能访问构造方法了
    private Singleton(){}
    //2,创建本类对象，private使外部不能随意更改
    private static final Singleton s = new Singleton();
    //3,对外提供公共的访问方法
    public static Singleton getInstance() {
            return s;
    }
}

饿汉式 是不管你用不用，上来就创建对象
懒汉式 是事先做个判断 什么时候用什么时候创建

//懒汉式, 单例的延迟加载模式 面试
class Singleton {
    //1,私有构造函数
    private Singleton(){}
    //2,声明一个本类的引用
    private static final Singleton s;
    //3,对外提供公共的访问方法
    public static Singleton getInstance() {
        if(s == null)
        //线程1,线程2
        s = new Singleton();
        return s;
    }
}

懒汉式在多线程使用时有安全隐患，有可能创建出多个对象出来。所以开发一般用饿汉式，面试一般是懒汉式。

饿汉式和懒汉式的区别
1,饿汉式是空间换时间,懒汉式是时间换空间
2,在多线程访问时,饿汉式不会创建多个对象,而懒汉式有可能会创建多个对象

单例设计模式在多线程的应用场景

RunTime类
Runtime类就是一个单例类

import java.io.IOException;

public class Demo2_Runtime {

    /**
     * @param args
     * @throws IOException 
     */
    public static void main(String[] args) throws IOException {
        Runtime r = Runtime.getRuntime();           //获取运行时对象
        //r.exec("shutdown -s -t 300");    //300秒后关机
        r.exec("shutdown -a");          //取消关机
    }

}

---

Timer计时器

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

public class Demo3_Timer {

    /**
     * @param args
     * @throws InterruptedException 
     */
    public static void main(String[] args) throws InterruptedException {
        Timer t = new Timer();
        //在指定时间安排指定任务
        //第一个参数,是安排的任务,第二个参数是执行的时间,第三个参数是过多长时间再重复执行
        t.schedule(new MyTimerTask(), new Date(188, 6, 1, 14, 22, 50),3000);    

        while(true) {
            Thread.sleep(1000);
            System.out.println(new Date());
        }
    }

}

class MyTimerTask extends TimerTask {

    @Override
    public void run() {
        System.out.println("起床背英语单词");
    }
}

执行时间的参数设置

---

线程间的通信

两个线程间的通信
1.什么时候需要通信
-多个线程并发执行时, 在默认情况下CPU是随机切换线程的
-如果我们希望他们有规律的执行, 就可以使用通信, 例如每个线程执行一次打印
2.怎么通信
- 如果希望线程等待, 就调用wait()
- 如果希望唤醒等待的线程, 就调用notify();
-这两个方法必须在同步代码中执行, 并且使用同步锁对象来调用

public class Demo1_Notify {

    /**
     * @param args
     * 等待唤醒机制
     */
    public static void main(String[] args) {
        final Printer p = new Printer();

        new Thread() {
            public void run() {
                while(true) {
                    try {
                        p.print1();
                    } catch (InterruptedException e) {

                        e.printStackTrace();
                    }
                }
            }
        }.start();

        new Thread() {
            public void run() {
                while(true) {
                    try {
                        p.print2();
                    } catch (InterruptedException e) {

                        e.printStackTrace();
                    }
                }
            }
        }.start();
    }

}

//等待唤醒机制
class Printer {
    private int flag = 1;
    public void print1() throws InterruptedException {                          
        synchronized(this) {
            if(flag != 1) {
                this.wait();                    //当前线程等待
            }
            System.out.print("华");
            System.out.print("中");
            System.out.print("科");
            System.out.print("技");
            System.out.print("大");
            System.out.print("学");
            System.out.print("\r\n");
            flag = 2;
            this.notify();                      //随机唤醒单个等待的线程
        }
    }

    public void print2() throws InterruptedException {
        synchronized(this) {
            if(flag != 2) {
                this.wait();
            }
            System.out.print("软");
            System.out.print("件");
            System.out.print("工");
            System.out.print("程");
            System.out.print("\r\n");
            flag = 1;
            this.notify();
        }
    }
}

1.在同步代码块中，用哪个对象锁，就用哪个对象调用wait方法
2.为什么wait方法和notify方法定义在Object这个类中？
因为锁对象可以是任意对象，Object是所有的类的基类，所以wait方法和notify方法需要定义在Object这个类中
3.sleep方法和wait方法的区别？
(1):sleep方法必须传入参数，时间到了就醒来
wait方法可以传入参数也可以不传入参数，传入参数就是在参数的时间结束后等待，不传入参数就是直接等待
(2):sleep方法在同步函数或同步代码块中，不释放锁
wait方法在同步函数或者代码块中释放锁，线程会放弃对象锁，进入等待此对象的等待锁定池

---

互斥锁

---

线程组

A:线程组概述
* Java中使用ThreadGroup来表示线程组，它可以对一批线程进行分类管理，Java允许程序直接对线程组进行控制。
* 默认情况下，所有的线程都属于主线程组。
* public final ThreadGroup getThreadGroup()//通过线程对象获取他所属于的组
* public final String getName()//通过线程组对象获取他组的名字
* 我们也可以给线程设置分组
* 1,ThreadGroup(String name) 创建线程组对象并给其赋值名字
* 2,创建线程对象
* 3,Thread(ThreadGroup?group, Runnable?target, String?name)
* 4,设置整组的优先级或者守护线程

public class Demo4_ThreadGroup {

    /**
     * @param args
     * ThreadGroup
     */
    public static void main(String[] args) {
        //demo1();
        ThreadGroup tg = new ThreadGroup("我是一个新的线程组");      //创建新的线程组
        MyRunnable mr = new MyRunnable();                       //创建Runnable的子类对象

        Thread t1 = new Thread(tg, mr, "张三");                   //将线程t1放在组中
        Thread t2 = new Thread(tg, mr, "李四");                   //将线程t2放在组中

        System.out.println(t1.getThreadGroup().getName());      //获取组名
        System.out.println(t2.getThreadGroup().getName());

        tg.setDaemon(true);
    }

    //自己设定线程组
    public static void demo1() {
        MyRunnable mr = new MyRunnable();
        Thread t1 = new Thread(mr, "张三");
        Thread t2 = new Thread(mr, "李四");

        ThreadGroup tg1 = t1.getThreadGroup();
        ThreadGroup tg2 = t2.getThreadGroup();

        System.out.println(tg1.getName());              //默认的是主线程
        System.out.println(tg2.getName());
    }

}

class MyRunnable implements Runnable {

    @Override
    public void run() {
        for(int i = 0; i < 1000; i++) {
            System.out.println(Thread.currentThread().getName() + "...." + i);
        }
    }

}

---

线程池

线程池概述
* 程序启动一个新线程成本是比较高的，因为它涉及到要与操作系统进行交互。而使用线程池可以很好的提高性能，尤其是当程序中要创建大量生存期很短的线程时，更应该考虑使用线程池。线程池里的每一个线程代码结束后，并不会死亡，而是再次回到线程池中成为空闲状态，等待下一个对象来使用。在JDK5之前，我们必须手动实现自己的线程池，从JDK5开始，Java内置支持线程池

内置线程池的使用概述
* JDK5新增了一个Executors工厂类来产生线程池，有如下几个方法
* public static ExecutorService newFixedThreadPool(int nThreads)
* public static ExecutorService newSingleThreadExecutor()
* 这些方法的返回值是ExecutorService对象，该对象表示一个线程池，可以执行Runnable对象或者Callable对象代表的线程。它提供了如下方法
* Future <?> submit(Runnable task)
* <T> Future<T> submit(Callable<T> task)

• 使用步骤：
  * 创建线程池对象
  * 创建Runnable实例
  * 提交Runnable实例
  * 关闭线程池

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class Demo5_Executors {

    /**
     * public static ExecutorService newFixedThreadPool(int nThreads)
     * public static ExecutorService newSingleThreadExecutor()
     */
    public static void main(String[] args) {
        ExecutorService pool = Executors.newFixedThreadPool(2);//创建线程池
        pool.submit(new MyRunnable());              //将线程放进池子里并执行
        pool.submit(new MyRunnable());

        pool.shutdown();                            //关闭线程池
    }

}

class MyRunnable implements Runnable {

    @Override
    public void run() {
        for(int i = 0; i < 1000; i++) {
            System.out.println(Thread.currentThread().getName() + "...." + i);
        }
    }

}

输出结果：