线程和线程池

一、Thread 类
　　构造方法：Thread()：创建新的线程
　　　　Thread(String name)：创建新的线程并指定改线程名
　　　　Thread(Runnable runnable)：创建新的线程并传入指定任务
　　常用方法：对象.start()：开始线程并执行任务
　　　　run()：要执行的任务
　　　　sleep(long millis)：暂停多少毫秒后执行
　　实现过程：
　　　　1、自定义类使之继承 Thread 类
　　　　2、重写run()方法
　　　　3、创建自定义类对象
　　　　4、调用start()方法

　　Demo：

　　自定义类

public class MyThread extends Thread {
    // run方法是用来描述线程任务的
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println(getName() + ":" + i);
        }
    }
}

开启线程

    public static void main(String[] args) {
        MyThread mt = new MyThread();
        // 开启线程
        mt.start();
        
        for (int i = 0; i < 100; i++) {
            System.out.println( Thread.currentThread().getName()+":"+ i);
        }
    }

 

 

二、Runnable 接口 （创建任务对象）
　　好处：创建的任务对象，可以被多次执行，Thread 自定义类执行继承，继承的单一性，但是 Runnable 接口，可以实现多实现，不再单一。
　　实现过程：
　　　　1、自定义类使之实现 Runnable 接口
　　　　2、重写Run 方法
　　　　3、创建 自定义类的 对象
　　　　4、创建 Thread 对象 并传入 指定任务对象 (自定义类对象)
　　　　5、调用 Thread 的 start() 方法，使之开始执行任务

　　Demo

　　自定义类

　　

public class MyRunnable implements Runnable {

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

开启线程

　

public static void main(String[] args) {
        Thread.currentThread().setName("System");
        // 创建线程任务对象
        MyRunnable mr = new MyRunnable();
                //创建线程对象，并传入任务
        Thread t = new Thread(mr);
        t.setName("YHYThread");
                //开启线程
        t.start();
        for (int i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread().getName() + ":" + i);
        }
    }

 

三、使用匿名内部类来实现多线程
1、使用 Thread
　　　　new Thread(){
　　　　　　重写run 方法
　　　　}.start();

　　　　

new Thread(new Runnable() {
            public void run() {
                Thread.currentThread().setName("YY");
                for (int i = 0; i < 100; i++) {
                    System.out.println(Thread.currentThread().getName() + ":" + i);
                }
            }
        }).start();

　　　　

2、使用 Runnable
　　　　Runnable r = new Runnable(){
　　　　　　重写run方法
　　　　};
　　　　Thread t = new Thread(r);
　　　　t.start();

　　　　

public static void main(String[] args) {
        Runnable r= new Runnable() {            
            @Override
            public void run() {
                System.out.println("任务");
            }
        };
        
        Thread t= new Thread(r);
        t.start();
    } 

 

四、线程池
　　创建线程池对象：
　　　　ExecutorService es = Executors.newFixedThreadPool(int nThreads);//传入需要开始线程的数量。

　　使用Runnable 接口实现线程池
　　　　　　1、创建Runnable的任务对象 并重写 run() 方法。
　　　　　　2、获取线程池对象
　　　　　　3、线程池对象.submit(Runnable task);//传入要执行的任务对象
　　　　　　4、关闭线程池对象 线程池对象.shutdown();

　　　　　　

    public static void main(String[] args) {
//        指定任务对象，可以使用自定义类，实现Runnable接口
        Runnable r = new Runnable() {
            @Override
            public void run() {
                System.out.println("任务");
            }
        };

//        获取线程池对象
        ExecutorService es = Executors.newFixedThreadPool(2);
//        指定任务
        es.submit(r);
//        关闭线程池
        es.shutdown();
    }

 

 

 

　　　　使用 Callable 接口实现线程池
　　　　　　1、创建 Callable 的任务对象，并重写 call() 方法。
　　　　　　2、创建线程池对象
　　　　　　3、线程池对象.submit(Callable c);//传入任务对象 （Callable 对象），假如有参数，使用Future<返回值类型> 接收
　　　　　　4、获取返回值 Future<返回值类型>对象.get() 获取 call() 方法的返回值
　　　　　　5、关闭线程池对象

　　　　　　

    public static void main(String[] args) throws InterruptedException, ExecutionException {
//        指定任务对象，并指定返回值，可以使用自定义类，实现Callable接口
        Callable<String> c = new Callable<String>() {
            @Override
            public String call() throws Exception {

                return "aaa";
            }
        };

//        获取线程池对象
        ExecutorService es = Executors.newFixedThreadPool(2);
//        传入指定任务并使用 Future<V> 接收返回值
        Future<String> submit = es.submit(c);
//        Future<V>对象 的 get() 方法接收返回值
        String str = submit.get();
        System.out.println(str);
//        关闭线程池
        es.shutdown();
    }

 

 

 

Callable 比Runable 的好处是：可以抛异常，可以有返回值

 

五、线程安全
　　当线程任务共享一个数据源，并对这个数据进行操作的时候，有可能出现错误数据，这个时候就要用同步代码块，或者同步方法。
　　　　1、定义一个同步代码块

　　　　　在 线程任务 方法外 定义任意对象 例如 

　　　　　　

package com.oracle.demo04;


public class Tickets implements Runnable {

//    所有线程共享数据放到成员位置
    private int ticks = 100;

//    创建枷锁
    Object lock = new Object();
    
    @Override
    public void run() {
        while (true) {
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            synchronized (lock) {
                if (ticks > 0) {
                    System.out.println(Thread.currentThread().getName() + "窗口卖了第:" + ticks-- + "张票");
                }
            }
        }

    }

}

 

　　将有肯能影响数据的地方用 synchronized(object){ 问题代码 } 

　　　2、定义一个同步方法 用 synchronized 修饰的方法

　　　　

package com.oracle.demo04;

public class Tickets2 implements Runnable {
//    所有线程共享数据放到成员位置
    private int ticks = 100;

//    创建枷锁
    Object lock = new Object();

    @Override
    public void run() {
        while (true) {
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            method();
        }
    }

    private synchronized void method() {

        if (ticks > 0) {
            System.out.println(Thread.currentThread().getName() + "窗口卖了第:" + ticks-- + "张票");
        }
    }
}

 

　　  然后在 线程任务中调用该方法。

　　　

　　　　3、使用 lock 类。控制 同步代码块　　

　　　　　　

package com.oracle.demo04;

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

public class Tickets3 implements Runnable {

//    所有线程共享数据放到成员位置
    private int ticks = 100;

    private Lock lock = new ReentrantLock();

    @Override
    public void run() {
        while (true) {

            lock.lock();
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
//            调用 lock 方法 获取锁
            if (ticks > 0) {
                System.out.println(Thread.currentThread().getName() + "窗口卖了第:" + ticks-- + "张票");
            }
            if(ticks > 3) {
                System.out.println(Thread.currentThread().getName() + "窗口卖了第:" + ticks-- + "张票");
            }
//            调用 unlock 方法 释放锁
            lock.unlock();
        }
    }

}