Java基础-8.线程、GUI

一、多线程

线程是程序执行的一条路径，一个进程中可以包含多条线程，多线程并发执行可以提高程序的效率，可以同时完成多项工作。

1.并行和并发

并行就是两个任务同时运行，就是甲任务进行的同时，乙任务也在进行。(需要多核CPU)

并发是指两个任务都请求运行，而处理器只能按受一个任务，就把这两个任务安排轮流进行，由于时间间隔较短，使人感觉两个任务都在运行。

2.Java程序运行原理

Java命令会启动java虚拟机，启动JVM，等于启动了一个应用程序，也就是启动了一个进程。该进程会自动启动一个“主线程”，然后主线程去调用某个类的main方法。JVM启动至少启动了垃圾回收线程和主线程，所以是多线程的。

3.多线程程序实现的方式1

定义类继承Thread，重写run方法，把新线程要做的事写在run方法中，创建线程对象，开启新线程，内部会自动执行run方法。主线程和自定义的线程会交替执行。

public class Demo2_Thread {

    public static void main(String[] args) {

        MyThread mt = new MyThread();       //4，创建自定义类的对象

        mt.start();                      //5，开启线程

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

            System.out.println("bb");

        }

    }

}

class MyThread extends Thread {  //1，定义类继承Thread

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

        for(int i = 0; i < 3000; i++) {  //3，将要执行的代码，写在run方法中

            System.out.println("aaaa");

        }

    }

}

4.多线程程序实现的方式2

定义类实现Runnable接口，实现run方法，把新线程要做的事写在run方法中，创建自定义的Runnable的子类对象，创建Thread对象，传入Runnable，调用start()开启新线程，内部会自动调用Runnable的run()方法。

public class Demo3_Runnable {

    public static void main(String[] args) {

        MyRunnable mr = new MyRunnable();    //4，创建自定义类对象

        //Runnable target = new MyRunnable();

        Thread t = new Thread(mr);     //5，将其当作参数传递给Thread的构造函数

        t.start();                    //6，开启线程

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

            System.out.println("bb");

        }

    }

}

class MyRunnable implements Runnable {    //1，自定义类实现Runnable接口

    @Override

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

        for(int i = 0; i < 3000; i++) {  //3，将要执行的代码，写在run方法中

            System.out.println("aa");

        }

    }

}

查看源码

1.看Thread类的构造函数，传递了Runnable接口的引用

2.通过init()方法找到传递的target给成员变量的target赋值

3.查看run方法，发现run方法中有判断，如果target不为null就会调用Runnable接口子类对象的run方法

5.两种方式的区别

查看源码的区别：

a.继承Thread : 由于子类重写了Thread类的run()，当调用start()时，直接找子类的run()方法

b.实现Runnable：Thread构造函数中传入了Runnable的引用，成员变量记住了它，start()调用run()方法时内部判断成员变量Runnable的引用是否为空，不为空编译时看的是Runnable的run()，运行时执行的是子类的run()方法

继承Thread

好处是：可以直接使用Thread类中的方法，代码简单

弊端是：如果已经有了父类，就不能用这种方法

实现Runnable接口

好处是：即使自己定义的线程类有了父类也没关系，因为有了父类也可以实现接口，而且接口是可以多实现的

弊端是：不能直接使用Thread中的方法需要先获取到线程对象后，才能得到Thread的方法，代码复杂

6.匿名内部类实现线程的两种方式

继承Thread类

new Thread() {                    //1，new 类(){}继承这个类

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

        for(int i = 0; i < 3000; i++) {   //3，将要执行的代码，写在run方法中

            System.out.println("aaaaa");

        }

    }

}.start();

实现Runnable接口

new Thread(new Runnable(){       //1，new 接口(){}实现这个接口

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

        for(int i = 0; i < 3000; i++) { //3，将要执行的代码，写在run方法中

            System.out.println("bb");

        }

    }

}).start();

7.获取名字和设置名字

通过getName()方法获取线程对象的名字，通过构造函数可以传入String类型的名字

new Thread("xxx") {

    public void run() {

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

            System.out.println(this.getName() + "....a");

        }

    }

}.start();

8.获取当前线程的对象

Thread.currentThread()， 主线程也可以获取

new Thread(new Runnable() {

    public void run() {

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

            System.out.println(Thread.currentThread().getName()+ "...aaaaaa");

        }

    }

}).start();

 

new Thread(new Runnable() {

    public void run() {

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

            System.out.println(Thread.currentThread().getName() + "...bb");

        }

    }

}).start();

Thread.currentThread().setName("我是主线程");   //获取主函数线程的引用，并改名字

System.out.println(Thread.currentThread().getName()); //获取主函数线程的引用，并获取名字

9.休眠线程

Thread.sleep(毫秒，纳秒)

new Thread() {

    public void run() {

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

            System.out.println(getName() + "...aa");

            try {

                Thread.sleep(10);

            } catch (InterruptedException e) {

                e.printStackTrace();

            }

        }

    }

}.start();

new Thread() {

    public void run() {

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

            System.out.println(getName() + "...bb");

            try {

                Thread.sleep(10);

            } catch (InterruptedException e) {

                e.printStackTrace();

            }

        }

    }

}.start();

10.守护线程

setDaemon()， 设置一个线程为守护线程，该线程不会单独执行，当其他非守护线程都执行结束后，自动退出

Thread t1 = new Thread() {

    public void run() {

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

            System.out.println(getName() + "...aaaaaa");

            try {

                Thread.sleep(10);

            } catch (InterruptedException e) {

                e.printStackTrace();

            }

        }

    }

};

Thread t2 = new Thread() {

    public void run() {

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

            System.out.println(getName() + "...bb");

            try {

                Thread.sleep(10);

            } catch (InterruptedException e) {

                e.printStackTrace();

            }

        }

    }

};

t1.setDaemon(true);    //将t1设置为守护线程

t1.start();

t2.start();

11加入线程

join()， 当前线程暂停，等待join的线程执行结束后，当前线程再继续

join(int)，可以等待指定的毫秒之后继续

final Thread t1 = new Thread() {

    public void run() {

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

            System.out.println(getName() + "...aaaaaaaaaaaaaaaaaaaaaa");

            try {

                Thread.sleep(10);

            } catch (InterruptedException e) {

                e.printStackTrace();

            }

        }

    }

};

 

Thread t2 = new Thread() {

    public void run() {

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

            if(i == 2) {

                try {

                    t1.join(30);    //加入，有固定的时间，过了固定时间，继续交替执行

                    Thread.sleep(10);

                } catch (InterruptedException e) {

                    e.printStackTrace();

                }

            }

            System.out.println(getName() + "...bb");

        }

    }

};

t1.start();

t2.start();

setPriority()设置线程的优先级

二、同步代码块

1.什么情况下需要同步

当多线程并发，有多段代码同时执行时，希望某一段代码执行的过程中CPU不要切换到其他线程工作，这时就需要同步。如果两段代码是同步的，那么同一时间只能执行一段，在一段代码没执行结束之前，不会执行另外一段代码。

使用synchronized关键字加上一个锁对象来定义一段代码，这就叫同步代码块，多个同步代码块如果使用相同的锁对象，那么他们就是同步的。

class Printer {

    Demo d = new Demo();

    public static void print1() {

        synchronized(d){   //锁对象可以是任意对象，但是被锁的代码需要保证是同一把锁，不能用匿名对象

            System.out.print("程");

            System.out.print("序");

            System.out.print("员");

            System.out.print("\r\n");

        }

    }

    public static void print2() {  

        synchronized(d){   

            System.out.print("播");

            System.out.print("客");

            System.out.print("\r\n");

        }

    }

}

public static void main(String[] args) {

        final Printer p = new Printer();

        new Thread() {

            public void run() {

                while(true) {

                    p.print1();

                }

            }

        }.start();
        
        new Thread() {

            public void run() {

                while(true) {

                    p.print2();

                }

            }

        }.start();

}

2.同步方法

使用synchronized关键字修饰一个方法， 该方法中所有的代码都是同步的

class Printer {

    public static void print1() {

        synchronized(Printer.class){    //锁对象可以是任意对象，但是被锁的代码需要保证是同一把锁，不能用匿名对象

            System.out.print("程");

            System.out.print("序");

            System.out.print("员");

            System.out.print("\r\n");

        }

    }

    /*

     * 非静态同步函数的锁是:this

     * 静态的同步函数的锁是:字节码对象

     */

    public static synchronized void print2() { 

        System.out.print("播");

        System.out.print("客");

        System.out.print("\r\n");

    }

}

3.线程安全问题

多线程并发操作同一数据时，就有可能出现线程安全问题，使用同步技术可以解决这种问题， 把操作数据的代码进行同步

public class Demo2_Synchronized {

        public static void main(String[] args) {

            TicketsSeller t1 = new TicketsSeller();

            TicketsSeller t2 = new TicketsSeller();

            TicketsSeller t3 = new TicketsSeller();

            TicketsSeller t4 = new TicketsSeller();

 

            t1.setName("窗口1");

            t2.setName("窗口2");

            t3.setName("窗口3");

            t4.setName("窗口4");

            t1.start();

            t2.start();

            t3.start();

            t4.start();

        }

    }

 

    class TicketsSeller extends Thread {

        private static int tickets = 100;

        static Object obj = new Object(); //如果不是静态，则每个对象都有不同的object

        public TicketsSeller() {

            super();

        }

        public TicketsSeller(String name) {

            super(name);

        }

        public void run() {

            while(true) {

                synchronized(obj) {

                    if(tickets <= 0)

                        break;

                    try {

                        Thread.sleep(10);

                    } catch (InterruptedException e) {

                        e.printStackTrace();

                    }

                    System.out.println(getName() + "...这是第" + tickets-- + "号票");

                }

            }

        }

    }

如果用runnable时，因为runnable只需要创建一次，所以需要传入锁对象。

多次启动一个线程是非法的。

4.死锁

多线程同步的时候，如果同步代码嵌套，使用相同锁，就有可能出现死锁，尽量不要嵌套使用

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.单例设计模式

保证类在内存中只有一个对象。

(1)控制类的创建，不让其他类来创建本类的对象。private

(2)在本类中定义一个本类的对象。Singleton s;

(3)提供公共的访问方式。 public static Singleton getInstance(){return s}

单例写法两种：

(1)饿汉式 开发用这种方式。

//饿汉式

class Singleton {

    //1,私有构造函数

    private Singleton(){}

    //2,创建本类对象

    private static Singleton s = new Singleton();

    //3,对外提供公共的访问方法

    public static Singleton getInstance() {

        return s;

    }

    public static void print() {

        System.out.println("11111111111");

    }

}

(2)懒汉式 面试写这种方式。多线程的问题？

//懒汉式,单例的延迟加载模式

class Singleton {

    //1,私有构造函数

    private Singleton(){}

    //2,声明一个本类的引用

    private static Singleton s;

    //3,对外提供公共的访问方法

    public static Singleton getInstance() {

        if(s == null)

            s = new Singleton();

        return s;

    }

    public static void print() {

        System.out.println("11111111111");

    }

}

(3)第三种格式

class Singleton {

    private Singleton() {}

    public static final Singleton s = new Singleton();//final是最终的意思，被final修饰的变量不可以被更改

}

2.Runtime类

Runtime类是一个单例类

Runtime r = Runtime.getRuntime();

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

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

3.Timer

Timer类：计时器

    public class Demo5_Timer {

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

            Timer t = new Timer();

            t.schedule(new MyTimerTask(), new Date(114,9,15,10,54,20),3000);

            while(true) {

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

                Thread.sleep(1000);

            }

        }

    }

    class MyTimerTask extends TimerTask {

        @Override

        public void run() {

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

        }

    }

4.两个线程间的通信

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

如果希望线程等待，就调用wait()

如果希望唤醒等待的线程，就调用notify();

这两个方法必须在同步代码中执行，并且使用同步锁对象来调用

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("\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("\r\n");

            flag = 1;

            this.notify();

        }

    }

}

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

notify()方法是随机唤醒一个线程

notifyAll()方法是唤醒所有线程

如果多个线程之间通信，需要使用notifyAll()通知所有线程，用while来反复判断条件

class Printer2 {

         private int flag = 1;

         public void print1() throws InterruptedException {                                                           

                  synchronized(this) {

                          while(flag != 1) {

                                   this.wait();                                          //当前线程等待

                          }

                          System.out.print("程");

                          System.out.print("序");

                          System.out.print("员");

                          System.out.print("\r\n");

                          flag = 2;

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

                          this.notifyAll();

                  }

         }

        

         public void print2() throws InterruptedException {

                  synchronized(this) {

                          while(flag != 2) {

                                   this.wait();           //线程2在此等待

                          }

                          System.out.print("播");

                          System.out.print("客");

                          System.out.print("\r\n");

                          flag = 3;

                          //this.notify();

                          this.notifyAll();

                  }

         }

        

         public void print3() throws InterruptedException {

                  synchronized(this) {

                          while(flag != 3) {

                                   this.wait();                     //线程3在此等待,if语句是在哪里等待,就在哪里起来

                                                                        //while循环是循环判断,每次都会判断标记

                          }

                          System.out.print("m");

                          System.out.print("i");

                          System.out.print("\r\n");

                          flag = 1;

                          //this.notify();

                          this.notifyAll();

                  }

         }

}

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

wait方法和notify方法定义在Object类中：因为锁对象可以是任意对象，Object是所有的类的基类，所以wait方法和notify方法需要定义在Object这个类中

sleep方法和wait方法的区别?

sleep方法必须传入参数，参数就是时间，时间到了自动醒来

wait方法可以传入参数也可以不传入参数，传入参数就是在参数的时间结束后等待，不传入参数就是直接等待

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

wait方法在同步函数或者同步代码块中，释放锁

6.互斥锁

1.同步

使用ReentrantLock类的lock()和unlock()方法进行同步

2.通信

使用ReentrantLock类的newCondition()方法可以获取Condition对象

需要等待的时候使用Condition的await()方法，唤醒的时候用signal()方法

不同的线程使用不同的Condition，这样就能区分唤醒的时候找哪个线程了

         public static void main(String[] args) {

                  final Printer3 p = new Printer3();

                  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();

                  new Thread() {

                          public void run() {

                                   while(true) {

                                            try {

                                                     p.print3();

                                            } catch (InterruptedException e) {        

                                                     e.printStackTrace();

                                            }

                                   }

                          }

                  }.start();

         }

}

 

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("程");

                          System.out.print("序");

                          System.out.print("员");

                          System.out.print("\r\n");

                          flag = 2;

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

                          c2.signal();

                  r.unlock();                                                                      //释放锁

         }

        

         public void print2() throws InterruptedException {

                  r.lock();

                          if(flag != 2) {

                                   c2.await();

                          }

                          System.out.print("播");

                          System.out.print("客");

                          System.out.print("\r\n");

                          flag = 3;

                          //this.notify();

                          c3.signal();

                  r.unlock();

         }

        

         public void print3() throws InterruptedException {

                  r.lock();

                          if(flag != 3) {

                                   c3.await();

                          }

                          System.out.print("m");

                          System.out.print("a");

                          System.out.print("\r\n");

                          flag = 1;

                          c1.signal();

                  r.unlock();

         }

}

 

四、线程组

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,设置整组的优先级或者守护线程

线程组的使用，默认是主线程组

MyRunnable mr = new MyRunnable();

Thread t1 = new Thread(mr, "张三");

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

//获取线程组

// 线程类里面的方法：public final ThreadGroup getThreadGroup()

ThreadGroup tg1 = t1.getThreadGroup();

ThreadGroup tg2 = t2.getThreadGroup();

// 线程组里面的方法：public final String getName()

String name1 = tg1.getName();

String name2 = tg2.getName();

System.out.println(name1);

System.out.println(name2);

// 通过结果我们知道了：线程默认情况下属于main线程组

// 通过下面的测试，你应该能够看到，默任情况下，所有的线程都属于同一个组

System.out.println(Thread.currentThread().getThreadGroup().getName());

自己设定线程组

// ThreadGroup(String name)

ThreadGroup tg = new ThreadGroup("这是一个新的组");

 

MyRunnable mr = new MyRunnable();

// Thread(ThreadGroup group, Runnable target, String name)

Thread t1 = new Thread(tg, mr, "张三");

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

 

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

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

 

//通过组名称设置后台线程，表示该组的线程都是后台线程

tg.setDaemon(true);

五、线程池

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

1.方法

JDK5新增了一个Executors工厂类来产生线程池，有如下几个方法

public static ExecutorService newFixedThreadPool(int nThreads)

public static ExecutorService newSingleThreadExecutor()

这些方法的返回值是ExecutorService对象，该对象表示一个线程池，可以执行Runnable对象或者Callable对象代表的线程。它提供了如下方法

Future<?> submit(Runnable task)

Future submit(Callable task)

2.使用步骤

创建线程池对象

创建Runnable实例

提交Runnable实例

关闭线程池

 

提交的是Runnable

// public static ExecutorService newFixedThreadPool(int nThreads)

ExecutorService pool = Executors.newFixedThreadPool(2);

// 可以执行Runnable对象或者Callable对象代表的线程

pool.submit(new MyRunnable());

pool.submit(new MyRunnable());

//结束线程池

pool.shutdown();

3.多线程程序实现的方式3

提交的是Callable

// 创建线程池对象

ExecutorService pool = Executors.newFixedThreadPool(2);

// 可以执行Runnable对象或者Callable对象代表的线程

Future<Integer> f1 = pool.submit(new MyCallable(100));

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

// V get()

Integer i1 = f1.get();

Integer i2 = f2.get();

 

System.out.println(i1);

System.out.println(i2);

// 结束

pool.shutdown();

 

public class MyCallable implements Callable<Integer> {

    private int number;

    public MyCallable(int number) {

        this.number = number;

    }

    @Override

    public Integer call() throws Exception {

        int sum = 0;

        for (int x = 1; x <= number; x++) {

            sum += x;

        }

        return sum;

    }

}

好处：可以有返回值、可以抛出异常

弊端：代码比较复杂，所以一般不用

六、GUI

1.Graphical User Interface(图形用户接口)

Frame  f = new Frame(“my window”);

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

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

f.setLocation(300,200);//设置窗体出现在屏幕的位置

f.setIconImage(Toolkit.getDefaultToolkit().createImage("qq.png"));

f.setVisible(true);

2.布局管理器

FlowLayout（流式布局管理器）

         * 从左到右的顺序排列。

         * Panel默认的布局管理器。

BorderLayout（边界布局管理器）

         * 东，南，西，北，中

         * Frame默认的布局管理器。

GridLayout（网格布局管理器）

         * 规则的矩阵

CardLayout（卡片布局管理器）

         * 选项卡

GridBagLayout（网格包布局管理器）

         * 非规则的矩阵

3.窗体监听

Frame f = new Frame("我的窗体");

//事件源是窗体,把监听器注册到事件源上

//事件对象传递给监听器

f.addWindowListener(new WindowAdapter() {

        public void windowClosing(WindowEvent e) {

              //退出虚拟机,关闭窗口

              System.exit(0);

       }

});

4.鼠标监听

        b1.addMouseListener(new MouseAdapter() {

            /*@Override

            public void mouseClicked(MouseEvent e) {    //单击

                System.exit(0);

            }*/

            @Override

            public void mouseReleased(MouseEvent e) {    //释放

                System.exit(0);

            }

        });

5.键盘监听

b1.addKeyListener(new KeyAdapter() {

         @Override

         public void keyReleased(KeyEvent e) {

                    //System.out.println(e.getKeyCode());

                     if(e.getKeyCode() == KeyEvent.VK_SPACE){

                                            System.exit(0);

                      }

         }

});

6.动作监听

b2.addActionListener(new ActionListener() {         //添加动作监听,应用场景就是暂停视频和播放视频

              @Override

              public void actionPerformed(ActionEvent e) {

                     System.exit(0);

              }

});

f.setVisible(true);

7.