多线程·线程间通信和 GUI

单例设计模式

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

* B：如何保证
　　* a：控制类的创建，不让其他类来创建泵类的对象，私有化构造方法
　　* b：在本类中定义一个本类的对象
　　* c：提供公共的访问方式

* C：案例演示
　　* 饿汉式，用空间换取时间
　　* 懒汉式，用时间换取空间

package com.heima.thread;

public class Demo1_Singleton {

    /*

     * 饿汉式和懒汉式的区别：

     * 1、饿汉式一开始就创建对象浪费空间，但是节省了时间，是用空间换取时间

     * 2、懒汉式一开始不创建对象，访问后才判断并创建，浪费了时间，是用时间换取空间

     * 3、在多线程访问时，懒汉式有可能创建多个对象

     * 4、开发中一般用饿汉式，懒汉式出现在面试中

     */

    public static void main(String[] args) {

        Singleton2 s1 = Singleton2.getInstance();

        Singleton2 s2 = Singleton2.getInstance();

        System.out.println(s1 == s2); // true，指向的是同一个对象

    }

}

class Singleton1 { // 饿汉式

    private Singleton1() {}// 私有构造方法，其他类不能访问该构造方法

    private static Singleton1 s = new Singleton1(); // 在本类中创建本类对象

    public static Singleton1 getInstance() { // 对外提供公共的访问方法

        return s;

    }

}

class Singleton2 { // 懒汉式，单例的延迟加载模式

    private Singleton2() {}// 私有构造方法，其他类不能访问该构造方法

    private static Singleton2 s; // 声明一个引用，但不创建

    public static Singleton2 getInstance() { // 对外提供公共的访问方法

        if (s == null) {

            // 多线程时可能会创建多个对象

            s = new Singleton2(); // 获取实例

        }

        return s;

    }

}

class Singleton3 { // 第三种方法

    private Singleton3() {}// 私有构造方法，其他类不能访问该构造方法

    public static final Singleton3 s = new Singleton3(); // 用final创建对象

}

Singleton

Runtime类

* Runtime类是一个单例类

package com.heima.thread;

import java.io.IOException;

public class Demo2_Runtime {

    public static void main(String[] args) throws IOException {

        Runtime r = Runtime.getRuntime(); // Runtime类中私有了构造方法，但内部创建了Runtime对象可以调用方法获取对象

        // r.exec("shutdown -s -t 300"); // 300秒后关机

        // r.exec("shutdown -a"); // 取消关机

    }

}

runtime

Timer类

* Timer类：计时器

package com.heima.thread;

import java.util.Date;

import java.util.Timer;

import java.util.TimerTask;

public class Demo3_Timer {

    public static void main(String[] args) throws InterruptedException {

        Timer t = new Timer();

        // 在指定时间安排指定任务，第一个参数是安排的任务，第二个参数是执行的时间，第三个参数是过多少毫秒后再重复执行

        t.schedule(new MyTimerTask(), new Date(120, 3, 12, 9, 3, 30), 3000);

                                        // 年-1900，月-1，日，时-1，分-1，秒-1

        while (true) {

            Thread.sleep(1000);

            System.out.println(new Date());

        }

    }

}

class MyTimerTask extends TimerTask { // 继承TimerTask

    @Override

    public void run() { // 重写 run()方法

        System.out.println("起床背英语");

    }

}

TimerTask

两个线程间的通信

* A：什么时候需要通信
　　* 多个线程并发执行时，在默认情况下CPU是随机切换线程的
　　* 如果我们希望他们有规律的执行，就可以使用通信，例如每个线程执行一次打印

* B：怎么通信
　　* 如果希望线程等待，就调用锁对象的 wait()方法
　　* 如果希望唤醒等待的线程，就调用 notify()
　　* 这两个方法必须在同步代码块中国执行，并且使用同步锁对象来调用

package com.heima.thread2;

public class Demo1_Notify {

    //  等待唤醒机制，交替打印

    public static void main(String[] args) {

        Printer p = new Printer();

        new Thread () {

            public void run() {

                while (true) {

                    try {

                        Thread.sleep(1);

                        p.print1();

                    } catch (InterruptedException e) {

                        e.printStackTrace();

                    }

                }

            }

        }.start(); // 开启线程 1

        new Thread () {

            public void run() {

                while (true) {

                    try {

                        Thread.sleep(1);

                        p.print2();

                    } catch (InterruptedException e) {

                        e.printStackTrace();

                    }

                }

            }

        }.start(); // 开启线程 2

    }

}

class Printer {

    private int flag = 1; // 定义特征变量

    public void print1() throws InterruptedException {

        synchronized (this) {

            if (flag != 1) {

                this.wait(); // 判断条件，使当前线程等待

            }

            System.out.print("z");

            System.out.print("w");

            System.out.print("b");

            System.out.println();    

            flag = 2; // 将特征变量修改为2

            this.notify(); // 随机唤醒单个等待的线程

        }

    }

    public void print2() throws InterruptedException {

        synchronized (this) {

            if (flag != 2) {

                this.wait(); // 判断条件，使当前线程等待

            }

            System.out.print("c");

            System.out.print("l");

            System.out.print("y");

            System.out.println();

            flag = 1; // 将特征变量修改为1

            this.notify(); // 随机唤醒单个等待的线程

        }

    }

}

Notifiy

三个或三个以上的线程间通信

* 多个线程通信的问题
　　* notify()方法，随机唤醒一个线程
　　* notifyAll()方法，唤醒所有线程
　　* JDK5之前无法唤醒指定的线程
　　* 如果多个线程间通信，需要使用 notifyAll()通知所有线程，并用 while来反复判断条件

package com.heima.thread2;

public class Demo2_NotifyAll {

    /*

     * 1、在同步代码块中，用哪个对象锁，就用哪个对象调用wait方法

     * 2、wait方法和notify方法定义在Object类中的原因是：锁对象可以是任何对象，而Object是所有类的基类，所以这两种方法需要定义在这个类中

     * 3、sleep和wait方法的区别：

     *         a：sleep：必须传入参数，参数就是时间，时间到了，就自动醒来

     *            wait：可以传参数也可以不传，如果传参数，就是在参数的时间结束后等待，如果不传入，就是立刻等待

     *         b：sleep：在同步函数或同步代码块中，不释放锁，睡着了也抱着锁睡

     *            wait：在同步函数或同步代码块中，释放锁

     */

    public static void main(String[] args) {

        Printer2 p2 = new Printer2();

        new Thread() {

            public void run() {

                while (true) {

                    try {

                        p2.print1();

                    } catch (InterruptedException e) {

                        e.printStackTrace();

                    }

                }

            }

        }.start(); // 开启线程1

        new Thread() {

            public void run() {

                while (true) {

                    try {

                        p2.print2();

                    } catch (InterruptedException e) {

                        e.printStackTrace();

                    }

                }

            }

        }.start(); // 开启线程2

        new Thread() {

            public void run() {

                while (true) {

                    try {

                        p2.print3();

                    } catch (InterruptedException e) {

                        e.printStackTrace();

                    }

                }

            }

        }.start(); // 开启线程3

    }

}

class Printer2 {

    private int flag = 1; // 定义特征变量

    public void print1() throws InterruptedException {

        synchronized (this) {

            while (flag != 1) {

                this.wait(); // 判断条件，使当前线程等待

            }

            System.out.print("z");

            System.out.print("w");

            System.out.print("b");

            System.out.println();    

            flag = 2; // 将特征变量修改为 2

            this.notifyAll(); // 唤醒所有等待的线程

        }

    }

    public void print2() throws InterruptedException {

        synchronized (this) {

            while (flag != 3) {

                this.wait(); // 判断条件，使当前线程等待

            }

            System.out.print("c");

            System.out.print("l");

            System.out.print("y");

            System.out.println();    

            flag = 1; // 将特征变量修改为 1

            this.notifyAll(); // 唤醒所有等待的线程

        }

    }

    public void print3() throws InterruptedException {

        synchronized (this) {

            while (flag != 2) {

                this.wait(); // 判断条件，使当前线程等待

            }

            System.out.print("x");

            System.out.print("h");

            System.out.print("n");

            System.out.println();    

            flag = 3; // 将特征变量修改为 3

            this.notifyAll(); // 唤醒所有等待的线程

        }

    }

}

NotifiyAll

互斥锁

* A：同步
　　* 使用 ReentrantLock类的 lock()方法和 unlock()方法

* B：通信
　　* 使用 ReentrantLock类的 newCondition() 方法可以获取 Condition对象
　　* 需要等待的时候使用 Condition的 await()方法，唤醒的时候使用 signal()方法
　　* 不同的线程使用不同的 Condition，这样就能区分唤醒的时候该找哪个线程了

package com.heima.thread2;

import java.util.concurrent.locks.Condition;

import java.util.concurrent.locks.ReentrantLock;

public class Demo3_ReentrantLock {

    public static void main(String[] args) {

        Printer3 p3 = new Printer3(); // 创建对象

        new Thread() {

            public void run() {

                while (true) {

                    try {

                        p3.print1();

                    } catch (InterruptedException e) {

                        e.printStackTrace();

                    }

                }

            }

        }.start(); // 开启线程 1

        new Thread() {

            public void run() {

                while (true) {

                    try {

                        p3.print2();

                    } catch (InterruptedException e) {

                        e.printStackTrace();

                    }

                }

            }

        }.start(); // 开启线程 2

        new Thread() {

            public void run() {

                while (true) {

                    try {

                        p3.print3();

                    } catch (InterruptedException e) {

                        e.printStackTrace();

                    }

                }

            }

        }.start(); // 开启线程 3

    }

}

class Printer3 {

    private ReentrantLock r = new ReentrantLock(); // 创建锁对象

    private Condition c1 = r.newCondition(); // 创建监视器

    private Condition c2 = r.newCondition();

    private Condition c3 = r.newCondition();

    private int flag = 1; // 创建特征变量

    public void print1() throws InterruptedException {

        r.lock(); // 获取锁

        if (flag != 1) {

            c1.await(); // 判断条件，使线程等待

        }

        System.out.print("z");

        System.out.print("w");

        System.out.print("b");

        System.out.println();

        flag = 2;

        c2.signal(); // 在当前线程等待前，唤醒指定线程

        r.unlock(); // 释放锁

    }

    public void print2() throws InterruptedException {

        r.lock(); // 获取锁

        if (flag != 3) {

            c3.await(); // 判断条件，使线程等待

        }

        System.out.print("c");

        System.out.print("l");

        System.out.print("y");

        System.out.println();

        flag = 1;

        c1.signal(); // 在当前线程等待前，唤醒指定线程

        r.unlock(); // 释放锁

    }

    public void print3() throws InterruptedException {

        r.lock();// 获取锁

        if (flag != 2) {

            c2.await(); // 判断条件，使线程等待

        }

        System.out.print("x");

        System.out.print("h");

        System.out.print("n");

        System.out.println();

        flag = 3;

        c3.signal(); // 在当前线程等待前，唤醒指定线程

        r.unlock();// 释放锁

    }

}

ReentrantLock

线程组的概述和使用

* A：线程组的概述
　　* Java中使用 ThreadGroup 来表示线程组，它可以对一批线程进行分类管理，Java允许程序直接对线程组进行控制
　　* 默认情况下，所有的线程都属于主线程
　　　　* public final ThreadGroup getThreadGroup() ：通过线程对象获取它所属于的组
　　　　* public final String getName() ：通过线程组对象获取它的组的名字

　　* 我们也可以给线程设置分组
　　　　* ThreadGroup(String name) ：创建线程组对象并给其赋值命名
　　　　* Thread(ThreadGroup group, Runnable target, String name) ：通过 Thread的构造创建线程并添加到指定组中
　　　　* 设置整组的优先级或者守护线程

* B：案例演示
　　* 线程组的使用，默认是主线程组

package com.heima.thread2;

public class Demo4_ThreadGroup {

    public static void main(String[] args) {

        // demo1();

        // demo2();

    }

    public static void demo2() {

        ThreadGroup tg = new ThreadGroup("新线程组"); // 创建新的线程组

        MyRunnable mr = new MyRunnable(); // 创建Runnable的子类对象

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

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

        System.out.println(t1.getThreadGroup().getName()); // 获取线程组的名字

        System.out.println(t2.getThreadGroup().getName());

        tg.setDaemon(true);

    }

    public static void demo1() {

        MyRunnable mr = new MyRunnable(); // 创建Runnable的子类

        Thread t1 = new Thread(mr, "张三"); // 创建线程对象并命名

        Thread t2 = new Thread(mr, "李四");

        ThreadGroup tg1 = t1.getThreadGroup(); // 获取该线程的所属的线程组，如果线程已终止，则返回null

        ThreadGroup tg2 = t1.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);

        }

    }

}

ThreadGroup

线程的五种状态

线程池的概述和使用

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

* B：内置线程池的使用概述
　　* 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实例
　　　　　　* 关闭线程池

* C：案例演示
　　* 提交的是 Runnable

package com.heima.thread2;

import java.util.concurrent.ExecutorService;

import java.util.concurrent.Executors;

public class Demo5_Executor {

    public static void main(String[] args) {

        ExecutorService pool = Executors.newFixedThreadPool(2); // 创建可存储指定数量的线程的线程池

        pool.submit(new MyRunnable()); // 将线程放进池子里并执行

        pool.submit(new MyRunnable());

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

    }

}

ThreadPool

package com.heima.thread2;

import java.util.concurrent.Callable;

import java.util.concurrent.ExecutionException;

import java.util.concurrent.ExecutorService;

import java.util.concurrent.Executors;

import java.util.concurrent.Future;

public class Demo6_Callable {

    public static void main(String[] args) throws InterruptedException, ExecutionException {

        ExecutorService pool = Executors.newFixedThreadPool(2); // 创建可容纳指定线程数的线程池

        Future<Integer> f1 = pool.submit(new MyCallable(10)); // 将线程放进池子里并执行

        Future<Integer> f2 = pool.submit(new MyCallable(20));

        System.out.println(f1.get());

        System.out.println(f2.get());

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

    }

}

class MyCallable implements Callable<Integer> {

    private int num;

    public MyCallable(int num) {

        super();

        this.num = num;

    }

    @Override

    public Integer call() throws Exception { // 重写 call()方法

        int sum = 0;

        for (int i = 0; i <= num; i++) {

            sum += i;

        }

        return sum;

    }

}

Callable

简单工厂模式概述和使用

* A：简单工厂模式概述
　　* 又叫静态工厂方法模式，它定义一个具体的工厂类负则创建一些类的实例

* B：优点
　　* 客户端不需要再负则对象的创建，从而明确了各个类的职责

* C：缺点
　　* 这个静态工厂类负责所有对象的创建，如果有新的对象增加，或者某些对象的创建方式不同，就需要不断地修改工厂类，不利于后期维护

* D：案例演示
　　* 动物抽象类：public abstract Animal{ public abstract void eat(); }
　　* 具体狗类：public class Dog extends Animal{ }
　　* 具体猫类：public class Cat extends Animal{ }
　　* 定义一个专门的类来创建对象

package com.heima.factory;

public abstract class Animal {

    public abstract void eat();

}

Animal

package com.heima.factory;

public class Cat extends Animal {

    public void eat() {

        System.out.println("猫吃鱼");

    }

}

Cat

package com.heima.factory;

public class Dog extends Animal {

    public void eat() {

        System.out.println("狗吃肉");

    }

}

Dog

package com.heima.factory;

public class AnimalFactory {

    /*public static Dog createDog() {

        return new Dog();

    }

    public static Cat createCat() {

        return new Cat();

    }*/

    // 上述方法复用性太差

    public static Animal createAnimal(String name) { // 多态返回

        if ("Dog".equals(name)) {

            return new Dog();

        } else if ("Cat".equals(name)) {

            return new Cat();

        } else {

            return null;

        }

    }

}

Factory

package com.heima.factory;

public class Test {

    public static void main(String[] args) {

        /*Dog d = AnimalFactory.createDog();

        System.out.println(d);*/

        Dog d = (Dog)AnimalFactory.createAnimal("Dog");

        d.eat();

        Cat c = (Cat)AnimalFactory.createAnimal("Cat");

        c.eat();

    }

}

Test

工厂方法模式的概述和使用

* A：工厂方法模式的概述
　　* 工厂方法模式中抽象工厂类负则定义出啊关键对象的接口，具体对象的创建工作由继承抽象工作的具体类实现

* B：优点：
　　* 客户端不需要再负则对象的创建，从而明确了各个类的职责，
　　　　如果有新的对象增加，只需要增加一个具体的工厂类即可，不影响已有的代码，后期维护容易，增强了系统的扩展性

* C：缺点：
　　* 需要额外的编写代码，增加了工作量

* D：案例演示

package com.heima.facMethod;

public abstract class Animal {

    public abstract void eat();

}

Animal

package com.heima.facMethod;

public interface Factory {

    public Animal createAnimal();

}

Factory

package com.heima.facMethod;

public class Cat extends Animal {

    public void eat() {

        System.out.println("猫吃鱼");

    }

}

Cat

package com.heima.facMethod;

public class Dog extends Animal {

    public void eat() {

        System.out.println("狗吃肉");

    }

}

Dog

package com.heima.facMethod;

public class CatFactory implements Factory {

    public Animal createAnimal() { // 多态

        return new Cat();

    }

}

CatFactory

package com.heima.facMethod;

public class DogFactory implements Factory {

    public Animal createAnimal() { // 多态

        return new Dog();

    }

}

DogFactory

package com.heima.facMethod;

public class Test {

    public static void main(String[] args) {

        DogFactory df = new DogFactory();

        Dog d = (Dog)df.createAnimal(); // 返回的是 Animal，需要强转

        d.eat();

    }

}

Test

创建一个窗口并显示

* A：Graphic User Interface（图像交互接口）

* B：布局管理器
　　* FlowLayOut（流式布局管理器）
　　　　* 居中排列，新内容从左到右排列
　　　　* Panel默认的布局管理器
　　* BorderLayOut（边界布局管理器）
　　　　* 东南西北中
　　　　* Frame默认的布局管理器
　　* GridLayOut（网格布局管理器）
　　　　* 选项卡
　　* CardLayOut（卡片布局管理器）
　　　　* 选项卡
　　* GridBagLayOut（网格包布局管理器）
　　　　* 非规则的矩阵

* C：监听器
　　* 窗体监听，鼠标箭头，键盘监听和键盘事件，动作监听

package com.heima.GUI;

import java.awt.Button;

import java.awt.FlowLayout;

import java.awt.Frame;

import java.awt.Toolkit;

import java.awt.event.ActionEvent;

import java.awt.event.ActionListener;

import java.awt.event.KeyAdapter;

import java.awt.event.KeyEvent;

import java.awt.event.MouseAdapter;

import java.awt.event.MouseEvent;

import java.awt.event.WindowAdapter;

import java.awt.event.WindowEvent;;

public class Demo1_Frame {

    public static void main(String[] args) {

        Frame f = new Frame("我的第一个窗口"); // 给框架一个标题

        f.setSize(400, 600); // 设置窗体的大小

        f.setLocation(400, 100); // 设置窗体出现的位置

        f.setIconImage(Toolkit.getDefaultToolkit().createImage("qq.png")); // 设置图标

        Button b1 = new Button("1"); // 创建按钮，并为其命名

        Button b2 = new Button("2");

        f.add(b1); // 将按钮添加到框架上

        f.add(b2);

        f.setLayout(new FlowLayout()); // 设置布局管理器

        f.addWindowListener(new WindowAdapter() { // 在框架上添加窗体监听，传入适配器的匿名子类对象

            @Override

            public void windowClosing(WindowEvent e) { // 重写 Closeing()方法，使得点击退出按钮时可以退出程序

                System.exit(0);

            }

        });

        b1.addMouseListener(new MouseAdapter() { // 在按钮上添加鼠标监听

            @Override

            public void mouseReleased(MouseEvent e) { // 释放鼠标，GUI退出

                System.exit(0);

            }

        });

        b1.addKeyListener(new KeyAdapter() { // 在按钮上添加键盘监听

            @Override

            public void keyReleased(KeyEvent e) {

                if (e.getKeyCode() == KeyEvent.VK_SPACE) { // 如果按空格键，就退出

                    System.exit(0);

                }

            }

        });

        b2.addActionListener(new ActionListener() { // 在按钮上添加动作监听，默认动作是空格和鼠标左键，应用场景，视频播放器的暂停

            @Override

            public void actionPerformed(ActionEvent e) {

                System.exit(0);

            }

        });

        f.setVisible(true); // 设置窗体可见

    }

}

GUI

适配器设计模式

* A：什么是适配器
　　* 在使用监听器的时候，需要定义一个类实践监听器接口
　　* 通常接口中有多个方法，而程序中不一定所有的都用大，但又必须重写，这很繁琐
　　* 适配器简化了这些操作，我们定义监听器时只要继承适配器，然后重写需要的方法即可

* B：适配器原理
　　* 适配器就是一个类，实现了监听器接口，所有抽象方法都重写了，但是方法全是空的
　　* 适配器类需要定义成抽象的，因为创建该类对象，调用空方法是没有意义的
　　* 目的就是为了简化程序员的操作，定义监听器时继承适配器，只重写需要的方法就可以了

package com.heima.adaptor;

public class Demo1_Adaptor {

    public static void main(String[] args) {

    }

}

class 鲁智深 extends 中间类 {

    public void 习武() {

        System.out.println("倒把垂杨柳");

        System.out.println("拳打镇关西");

        System.out.println("大闹野猪林");

    }

}

abstract class 中间类 implements 和尚 { // 适配器，不想被实例化，声明成抽象，方法都是空的

    @Override

    public void 打坐() {

    }

    @Override

    public void 念经() {

    }

    @Override

    public void 撞钟() {

    }

    @Override

    public void 习武() {

    }

}

interface 和尚 {

    public void 打坐();

    public void 念经();

    public void 撞钟();

    public void 习武();

}

Adaptor

巴特西

Java 多线程 02

多线程·线程间通信和 GUI

单例设计模式

Runtime类

Timer类

两个线程间的通信

三个或三个以上的线程间通信

互斥锁

线程组的概述和使用

线程的五种状态

线程池的概述和使用

简单工厂模式概述和使用

工厂方法模式的概述和使用

创建一个窗口并显示

适配器设计模式

最新文章

热门文章

巴特西

Java 多线程 02

多线程·线程间通信 和 GUI

单例设计模式

Runtime类

Timer类

两个线程间的通信

三个或三个以上的线程间通信

互斥锁

线程组的概述和使用

线程的五种状态

线程池的概述和使用

简单工厂模式概述和使用

工厂方法模式的概述和使用

创建一个窗口并显示

适配器设计模式

最新文章

热门文章

多线程·线程间通信和 GUI