Java API —— 多线程

1、多线程概述

1）进程：

正在运行的程序，是系统进行资源分配和调用的独立单位。

每一个进程都有它自己的内存空间和系统资源。

2）线程：

在同一个进程内又可以执行多个任务，而这每一个任务我就可以看出是一个线程。

　　　　线程：是程序的执行单元，执行路径。是程序使用CPU的最基本单位。

　　　　单线程：程序只有一条执行路径。

　　　　多线程：程序有多条执行路径。

3）多线程有什么意义?

　　　　多线程的存在，不是提高程序的执行速度。其实是为了提高应用程序的使用率。

　　　　程序的执行其实都是在抢CPU的资源，CPU的执行权。多个进程是在抢这个资源，而其中的某一个进程如果执行路径比较多，就会有更高的几率抢到CPU的执行权。我们是不敢保证哪一个线程能够在哪个时刻抢到，所以线程的执行有随机性。

4）并行和并发

并发是逻辑上同时发生，指在某一个时间内同时运行多个程序。

并行是物理上同时发生，指在某一个时间点同时运行多个程序。

5）Java程序运行原理

java 命令会启动 java 虚拟机，启动 JVM，等于启动了一个应用程序，也就是启动了一个进程。该进程会自动启动一个 “主线程” ，然后主线程去调用某个类的 main 方法。所以 main方法运行在主线程中。在此之前的所有程序都是单线程的。

jvm虚拟机的启动是多线程的。因为垃圾回收线程也要先启动，否则很容易会出现内存溢出。现在的垃圾回收线程加上前面的主线程，最少启动了两个线程，所以，jvm的启动是多线程的。

2、多线程实现方案

　　1） Java可以去调用C/C++写好的程序来实现多线程程序。由C/C++去调用系统功能创建进程，然后由Java去调用这样的东西，然后提供一些类供我们使用。我们就可以实现多线程程序了。

　　2）实现方式1：继承Thread类。将类声明为 Thread 的子类。该子类应重写 Thread 类的 run 方法。接下来可以分配并启动该子类的实例。

A：自定义类MyThread继承Thread类。

B：MyThread类里面重写run()

C：创建对象

D：启动线程

例子1：

自定义线程类：

package threaddemos;
/*
 * 该类要重写run()方法,为什么呢?
 * 不是类中的所有代码都需要被线程执行的。
 * 而这个时候，为了区分哪些代码能够被线程执行，java提供了Thread类中的run()用来包含那些被线程执行的代码。
 */
public class MyThread extends Thread{
    @Override
    public void run(){
        for (int x = 0; x < 200; x++) {
            System.out.println(x);
        }
    }
}

测试类：

package threaddemos;
/**
 * Created by gao on 16-1-3.
 */
public class ThreadDemo01 {
    public static void main(String[] args) {
        // 创建线程对象
        // MyThread my = new MyThread();
        // // 启动线程
        // my.run();
        // my.run();
        // 调用run()方法为什么是单线程的呢?
        // 因为run()方法直接调用其实就相当于普通的方法调用,所以你看到的是单线程的效果
        // 面试题：run()和start()的区别?
        // run():仅仅是封装被线程执行的代码，直接调用是普通方法
        // start():首先启动了线程，然后再由jvm去调用该线程的run()方法。
        // MyThread my = new MyThread();
        // my.start();
        // // IllegalThreadStateException:非法的线程状态异常
        // // 为什么呢?因为这个相当于是my线程被调用了两次。而不是两个线程启动。
        // my.start();
        // 创建两个线程对象
        MyThread my1 = new MyThread();
        MyThread my2 = new MyThread();
        my1.start();
        my2.start();
    }
}

　　3）Thread类的基本获取和设置方法

public final String getName()：返回该线程的名称。

public final void setName(String name)：改变线程名称，使之与参数 name 相同。

其实通过构造方法也可以给线程起名字

　　4）获取main方法所在的线程名称

public static Thread currentThread()：返回对当前正在执行的线程对象的引用。

例子2：

自定义线程：

package threaddemos;
public class MyThread2 extends Thread {
    public MyThread2() {
    }
    public MyThread2(String name) {
        super(name);
    }
    @Override
    public void run() {
        for (int x = 0; x < 200; x++) {
            System.out.println(getName() + "---" + x);
        }
    }
}

测试类：

package threaddemos;
/**
 * Created by gao on 16-1-3.
 */
public class ThreadDemo02 {
    public static void main(String[] args) {
        // 创建线程对象
        //无参构造+setXxx()
//        MyThread2 my1 = new MyThread2();
//        MyThread2 my2 = new MyThread2();
//        my1.setName("林青霞");
//        my2.setName("刘意");
//        my1.start();
//        my2.start();
        //带参构造方法给线程起名字
        MyThread2 my1 = new MyThread2("林青霞");
        MyThread2 my2 = new MyThread2("刘意");
        my1.start();
        my2.start();
        //获取main方法所在的线程对象的名称
        //public static Thread currentThread():返回当前正在执行的线程对象
        System.out.println(Thread.currentThread().getName());
    }
}
/*
名称为什么是：Thread-? 编号
class Thread {
    private char name[];
    public Thread() {
        init(null, null, "Thread-" + nextThreadNum(), 0);
    }
    private void init(ThreadGroup g, Runnable target, String name,
                      long stackSize) {
        init(g, target, name, stackSize, null);
    }
     private void init(ThreadGroup g, Runnable target, String name,
                      long stackSize, AccessControlContext acc) {
        //大部分代码被省略了
        this.name = name.toCharArray();
    }
    public final void setName(String name) {
        this.name = name.toCharArray();
    }
    private static int threadInitNumber; //0,1,2
    private static synchronized int nextThreadNum() {
        return threadInitNumber++; //return 0,1
    }
    public final String getName() {
        return String.valueOf(name);
    }
}
class MyThread extends Thread {
    public MyThread() {
        super();
    }
}
*/

　　5）实现方式2：声明实现 Runnable 接口的类。该类然后实现 run 方法。然后可以分配该类的实例，在创建 Thread 时作为一个参数来传递并启动。

A:自定义类MyRunnable实现Runnable接口

B:重写run()方法

C:创建MyRunnable类的对象

D:创建Thread类的对象，并把C步骤的对象作为构造参数传递

自定义类：

package threaddemos;
/**
 * Created by gao on 16-1-4.
 */
public class MyRunnable implements Runnable {
    @Override
    public void run() {
        for (int x = 0; x < 100; x++) {
            // 由于实现接口的方式就不能直接使用Thread类的方法了,但是可以间接的使用
            System.out.println(Thread.currentThread().getName() + "---" + x);
        }
    }
}

测试类：

package threaddemos;
/**
 * Created by gao on 16-1-4.
 */
public class MyRunnableDemo {
    public static void main(String[] args) {
        // 创建MyRunnable类的对象
        MyRunnable my = new MyRunnable();
        // 创建Thread类的对象，并把C步骤的对象作为构造参数传递
        // Thread(Runnable target)
        // Thread t1 = new Thread(my);
        // Thread t2 = new Thread(my);
        // t1.setName("林青霞");
        // t2.setName("刘意");
        // Thread(Runnable target, String name)
        Thread t1 = new Thread(my,"林青霞");
        Thread t2 = new Thread(my,"刘意");
        t1.start();
        t2.start();
    }
}

　　6）多线程两种方式的图解比较和区别：

3、线程调度和线程控制
　　1）线程调度
　　　　假如我们的计算机只有一个 CPU，那么 CPU 在某一个时刻只能执行一条指令，线程只有得到 CPU时间片，也就是使用权，才可以执行指令。那么Java是
　　　　如何对线程进行调用的呢？
　　　　线程有两种调度模型：
　　　　　　· 分时调度模型：所有线程轮流使用 CPU 的使用权，平均分配每个线程占用 CPU 的时间片.
　　　　　　· 抢占式调度模型：优先让优先级高的线程使用 CPU，如果线程的优先级相同，那么会随机选择一个，优先级高的线程获取的 CPU 时间片相对多一些。
　　　　　　· Java使用的是抢占式调度模型。
　　2）设置和获取线程优先级
　　　　· public final int getPriority()：返回线程的优先级。
　　　　· public final void setPriority(int newPriority)：更改线程的优先级。

package threaddemos;
/**
 * Created by gao on 16-1-4.
 */
/*
 * 我们的线程没有设置优先级,肯定有默认优先级。
 * 获取线程对象的优先级
 *         public final int getPriority():返回线程对象的优先级
 * 设置线程对象的优先级
 *         public final void setPriority(int newPriority)：更改线程的优先级。
 *
 * 注意：
 *         线程默认优先级是5。
 *         线程优先级的范围是：1-10。
 *         线程优先级高仅仅表示线程获取的 CPU时间片的几率高，但是要在次数比较多，或者多次运行的时候才能看到比较好的效果。
 *
 * IllegalArgumentException:非法参数异常。
 * 抛出的异常表明向方法传递了一个不合法或不正确的参数。
 */
public class ThreadPriorityDemo01 {
    public static void main(String[] args) {
        ThreadPriority tp1 = new ThreadPriority();
        ThreadPriority tp2 = new ThreadPriority();
        ThreadPriority tp3 = new ThreadPriority();
        tp1.setName("东方不败");
        tp2.setName("岳不群");
        tp3.setName("林平之");
        // 获取默认优先级
        // System.out.println(tp1.getPriority()); //5
        // System.out.println(tp2.getPriority());//5
        // System.out.println(tp3.getPriority());//5
        // 设置线程优先级(范围出错)
        // tp1.setPriority(100000);
        //设置正确的线程优先级
        tp1.setPriority(10);
        tp3.setPriority(1);
        tp1.start();
        tp2.start();
        tp3.start();
    }
}

　　3）线程控制

· 线程休眠

public static void sleep(long millis)：在指定的毫秒数内让当前正在执行的线程休眠（暂停执行），此操作受到系统计时器和调度程序精度和准确性的影响。

· 线程加入

public final void join()：等待该线程终止。

· 线程礼让

public static void yield()：暂停当前正在执行的线程对象，并执行其他线程。

· 后台线程

public final void setDaemon(boolean on)：将该线程标记为守护线程或用户线程。当正在运行的线程都是守护线程时，Java 虚拟机退出。该方法必须在启动线程前调用。

· 中断线程

public final void stop()：已过时。不建议使用

public void interrupt()：中断线程

例子1：

自定义Thread类：

package threaddemos;
import java.util.Date;
/**
 * Created by gao on 16-1-4.
 */
public class ThreadSleep extends Thread {
    public ThreadSleep() {
    }
    @Override
    public void run() {
        for (int x = 0; x < 100; x++) {
            System.out.println(getName() + "---" + x + "日期：" + new Date());
            //睡眠,1秒钟
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

测试类：

package threaddemos;
/**
 * Created by gao on 16-1-4.
 */
/*
 * 线程休眠
 *        public static void sleep(long millis)
 */
public class ThreadSleepDemo {
    public static void main(String[] args) {
        ThreadSleep ts1 = new ThreadSleep();
        ThreadSleep ts2 = new ThreadSleep();
        ThreadSleep ts3 = new ThreadSleep();
        ts1.setName("林青霞");
        ts2.setName("林志玲");
        ts3.setName("林志颖");
        ts1.start();
        ts2.start();
        ts3.start();
        ts3.start();
    }
}

例子2：

ThreadJoin类：

package cn.itcast_04;
public class ThreadJoin extends Thread {
    @Override
    public void run() {
        for (int x = 0; x < 100; x++) {
            System.out.println(getName() + ":" + x);
        }
    }
}

测试类：

package cn.itcast_04;
/*
 * public final void join():等待该线程终止。 
 */
public class ThreadJoinDemo {
    public static void main(String[] args) {
        ThreadJoin tj1 = new ThreadJoin();
        ThreadJoin tj2 = new ThreadJoin();
        ThreadJoin tj3 = new ThreadJoin();
        tj1.setName("李渊");
        tj2.setName("李世民");
        tj3.setName("李元霸");
        tj1.start();
        try {
            tj1.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        
        tj2.start();
        tj3.start();
    }
}

例子3：

ThreadYield类：

package cn.itcast_04;
public class ThreadYield extends Thread {
    @Override
    public void run() {
        for (int x = 0; x < 100; x++) {
            System.out.println(getName() + ":" + x);
            Thread.yield();
        }
    }
}

测试类：

package cn.itcast_04;
/*
 * public static void yield():暂停当前正在执行的线程对象，并执行其他线程。 
 * 让多个线程的执行更和谐，但是不能靠它保证一人一次。
 */
public class ThreadYieldDemo {
    public static void main(String[] args) {
        ThreadYield ty1 = new ThreadYield();
        ThreadYield ty2 = new ThreadYield();
        ty1.setName("林青霞");
        ty2.setName("刘意");
        ty1.start();
        ty2.start();
    }
}

例子4：

package cn.itcast_04;
/*
 * public final void setDaemon(boolean on):将该线程标记为守护线程或用户线程。
 * 当正在运行的线程都是守护线程时，Java 虚拟机退出。 该方法必须在启动线程前调用。 
 * 
 * 游戏：坦克大战。
 */
public class ThreadDaemonDemo {
    public static void main(String[] args) {
        ThreadDaemon td1 = new ThreadDaemon();
        ThreadDaemon td2 = new ThreadDaemon();
        td1.setName("关羽");
        td2.setName("张飞");
        // 设置收获线程
        td1.setDaemon(true);
        td2.setDaemon(true);
        td1.start();
        td2.start();
        Thread.currentThread().setName("刘备");
        for (int x = 0; x < 5; x++) {
            System.out.println(Thread.currentThread().getName() + ":" + x);
        }
    }
}

例子5：

ThreadStop类：

package cn.itcast_04;
import java.util.Date;
public class ThreadStop extends Thread {
    @Override
    public void run() {
        System.out.println("开始执行：" + new Date());
        // 我要休息10秒钟，亲，不要打扰我哦
        try {
            Thread.sleep(10000);
        } catch (InterruptedException e) {
            // e.printStackTrace();
            System.out.println("线程被终止了");
        }
        System.out.println("结束执行：" + new Date());
    }
}

测试类：

package cn.itcast_04;
/*
 * public final void stop():让线程停止，过时了，但是还可以使用。
 * public void interrupt():中断线程。 把线程的状态终止，并抛出一个InterruptedException。
 */
public class ThreadStopDemo {
    public static void main(String[] args) {
        ThreadStop ts = new ThreadStop();
        ts.start();
        // 你超过三秒不醒过来，我就干死你
        try {
            Thread.sleep(3000);
            // ts.stop();
            ts.interrupt();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

4、线程生命周期

5、卖电影票案例

1）方式一：继承Thread类

自定义类：

package threaddemos;
/**
 * Created by gao on 16-1-4.
 */
public class SellTicket extends Thread {
    // 定义100张票
    // private int tickets = 100;
    // 为了让多个线程对象共享这100张票，我们其实应该用静态修饰
    private static int tickets = 100;
    @Override
    public void run() {
        // 定义100张票
        // 每个线程进来都会走这里，这样的话，每个线程对象相当于买的是自己的那100张票，这不合理，所以应该定义到外面
        // int tickets = 100;
        // 是为了模拟一直有票
        while (true) {
            if (tickets > 0) {
                System.out.println(getName() + "---" + "正在出售第" + (tickets--) + "张票");
            }
        }
    }
}

测试类：

package threaddemos;
/**
 * Created by gao on 16-1-4.
 */
/*
 * 某电影院目前正在上映贺岁大片(红高粱,少林寺传奇藏经阁)，共有100张票，而它有3个售票窗口售票，请设计一个程序模拟该电影院售票。
 * 继承Thread类来实现。
 */
public class SellTicketDemo {
    public static void main(String[] args) {
        // 创建三个线程对象
        SellTicket st1 = new SellTicket();
        SellTicket st2 = new SellTicket();
        SellTicket st3 = new SellTicket();
        // 给线程对象起名字
        st1.setName("窗口1");
        st2.setName("窗口2");
        st3.setName("窗口3");
        // 启动线程
        st1.start();
        st2.start();
        st3.start();
    }
}

2）方式二：实现Runnable接口

自定义类：

package threaddemos;
/**
 * Created by gao on 16-1-4.
 */
public class SellTicket2 implements Runnable {
    private int tickets = 200;
    @Override
    public void run() {
        while (true) {
            if (tickets > 0) {
                System.out.println(Thread.currentThread().getName() + "---" + "正在出售第" + (tickets--) + "张票");
            }
        }
    }
}

测试类：

package threaddemos;
/**
 * Created by gao on 16-1-4.
 */
/*
 *  实现Runnable接口的方式实现
 */
public class SellTicketDemo2 {
    public static void main(String[] args) {
        // 创建资源对象
        SellTicket2 st = new SellTicket2();
        // 创建三个线程对象
       Thread t1 = new Thread(st,"窗口1");
       Thread t2 = new Thread(st,"窗口2");
       Thread t3 = new Thread(st,"窗口3");
        // 启动线程
        t1.start();
        t2.start();
        t3.start();
    }
}

6、线程同步

1）出现的问题：

· 相同的票出现多次：CPU的一次操作必须是原子性的

· 还出现了负数的票：随机性和延迟导致的

2）解决线程安全问题的基本思想

· 首先想为什么出现问题?(也是我们判断是否有问题的标准)

A：是否是多线程环境

B：是否有共享数据

C：是否有多条语句操作共享数据

· 如何解决多线程安全问题呢?

· 基本思想：让程序没有安全问题的环境。

· 怎么实现呢?

· 把多个语句操作共享数据的代码给锁起来，让任意时刻只能有一个线程执行即可。

3）解决线程安全问题实现1：同步代码块

格式：

　　　　synchronized(对象){需要同步的代码;}

同步可以解决安全问题的根本原因就在那个对象上。该对象如同锁的功能。

同步代码块是把多条语句操作共享数据的代码的部分给包起来。

package threaddemos;
/**
 * Created by gao on 16-1-4.
 */
public class SellTicket3 implements Runnable {
    // 定义100张票
    private int tickets = 50;
    //创建锁对象
    private Object obj = new Object();
    @Override
    public void run() {
        while (true) {
            synchronized (obj) {
                if (tickets > 0) {
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName()
                            + "正在出售第" + (tickets--) + "张票");
                }
            }
        }
    }
//    @Override
//    public void run() {
//
//        while (true) {
//            if (tickets > 0) {
//                System.out.println(Thread.currentThread().getName() + "---" + "正在出售第" + (tickets--) + "张票");
//            }
//        }
//    }
}
测试类：
package threaddemos;
/**
 * Created by gao on 16-1-4.
 */
/*
 *  实现Runnable接口的方式实现
 */
public class SellTicketDemo3 {
    public static void main(String[] args) {
        // 创建资源对象
        SellTicket3 st = new SellTicket3();
        // 创建三个线程对象
       Thread t1 = new Thread(st,"窗口1");
       Thread t2 = new Thread(st,"窗口2");
       Thread t3 = new Thread(st,"窗口3");
        // 启动线程
        t1.start();
        t2.start();
        t3.start();
    }
}

　 4）同步的特点

· 同步的前提

· 多个线程

· 多个线程使用的是同一个锁对象

· 同步的好处

· 同步的出现解决了多线程的安全问题。

· 同步的弊端

· 当线程相当多时，因为每个线程都会去判断同步上的锁，这是很耗费资源的，无形中会降低程序的运行效率。

5）解决线程安全问题实现2

package threaddemos;
/**
 * Created by gao on 16-1-4.
 */
public class SellTicket4 implements Runnable {
    // 定义100张票
    private static int tickets = 100;
    // 定义同一把锁
    private Object obj = new Object();
    private Demo d = new Demo();
    private int x = 0;
    //同步代码块用obj做锁
//    @Override
//    public void run() {
//        while (true) {
//            synchronized (obj) {
//                if (tickets > 0) {
//                    try {
//                        Thread.sleep(100);
//                    } catch (InterruptedException e) {
//                        e.printStackTrace();
//                    }
//                    System.out.println(Thread.currentThread().getName()
//                            + "正在出售第" + (tickets--) + "张票 ");
//                }
//            }
//        }
//    }
    //同步代码块用任意对象做锁
//    @Override
//    public void run() {
//        while (true) {
//            synchronized (d) {
//                if (tickets > 0) {
//                    try {
//                        Thread.sleep(100);
//                    } catch (InterruptedException e) {
//                        e.printStackTrace();
//                    }
//                    System.out.println(Thread.currentThread().getName()
//                            + "正在出售第" + (tickets--) + "张票 ");
//                }
//            }
//        }
//    }
    @Override
    public void run() {
        while (true) {
            if(x%2==0){
                //加载class文件当锁
                synchronized (SellTicket.class) {
                    if (tickets > 0) {
                        try {
                            Thread.sleep(100);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        System.out.println(Thread.currentThread().getName()
                                + "正在出售第" + (tickets--) + "张票 ");
                    }
                }
            }else {
//                synchronized (d) {
//                    if (tickets > 0) {
//                        try {
//                            Thread.sleep(100);
//                        } catch (InterruptedException e) {
//                            e.printStackTrace();
//                        }
//                        System.out.println(Thread.currentThread().getName()
//                                + "正在出售第" + (tickets--) + "张票 ");
//                    }
//                }
                sellTicket();
            }
            x++;
        }
    }
//    private void sellTicket() {
//        synchronized (d) {
//            if (tickets > 0) {
//            try {
//                    Thread.sleep(100);
//            } catch (InterruptedException e) {
//                    e.printStackTrace();
//            }
//            System.out.println(Thread.currentThread().getName()
//                        + "正在出售第" + (tickets--) + "张票 ");
//            }
//        }
//    }
    //如果一个方法一进去就看到了代码被同步了，那么我就再想能不能把这个同步加在方法上呢?
//     private synchronized void sellTicket() {
//            if (tickets > 0) {
//            try {
//                    Thread.sleep(100);
//            } catch (InterruptedException e) {
//                    e.printStackTrace();
//            }
//            System.out.println(Thread.currentThread().getName()
//                        + "正在出售第" + (tickets--) + "张票 ");
//            }
//    }
    private static synchronized void sellTicket() {
        if (tickets > 0) {
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()
                    + "正在出售第" + (tickets--) + "张票 ");
        }
    }
}
class Demo {
}

测试类：

package threaddemos;
/**
 * Created by gao on 16-1-4.
 */
/*
 *  实现Runnable接口的方式实现
 */
    /*
 * A:同步代码块的锁对象是谁呢?
 *         任意对象。
 *
 * B:同步方法的格式及锁对象问题?
 *         把同步关键字加在方法上。
 *
 *         同步方法是谁呢?
 *             this
 *
 * C:静态方法及锁对象问题?
 *         静态方法的锁对象是谁呢?
 *             类的字节码文件对象。
 */
public class SellTicketDemo4 {
    public static void main(String[] args) {
        // 创建资源对象
        SellTicket3 st = new SellTicket3();
        // 创建三个线程对象
       Thread t1 = new Thread(st,"窗口1");
       Thread t2 = new Thread(st,"窗口2");
       Thread t3 = new Thread(st,"窗口3");
        // 启动线程
        t1.start();
        t2.start();
        t3.start();
    }
}

6）以往的线程安全类

package cn.itcast_12;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Hashtable;
import java.util.List;
import java.util.Vector;
public class ThreadDemo {
    public static void main(String[] args) {
        // 线程安全的类
        StringBuffer sb = new StringBuffer();
        Vector<String> v = new Vector<String>();
        Hashtable<String, String> h = new Hashtable<String, String>();
        // Vector是线程安全的时候才去考虑使用的，但是不会用Vector，而是用下面的。
        // public static <T> List<T> synchronizedList(List<T> list)
        List<String> list1 = new ArrayList<String>();// 线程不安全
        List<String> list2 = Collections
                .synchronizedList(new ArrayList<String>()); // 线程安全
    }
}

posted @ 2016-01-04 11:10 我是一名老菜鸟阅读(2168) 评论(0) 编辑收藏举报

刷新页面返回顶部

Java API —— 多线程

公告