多线程

实现多线程的方式

方法1：Thread类

继承Thread类

start方法启动

方法2：Runnable接口

实现接口class MyRun implement Runnable....

重写run方法

创建一个线程MyRun p = new MyRum

启动线程运行new Thread(p).start()

方法3：Callable接口（了解就行）

实现接口

重写call方法，需要抛出异常

创建目标对象

创建执行服务：ExecutorService ser =Executors.newFixedThreadPool(1);

提交执行：Future<boolean>result1 = ser.submit(t1)</boolean>

获取结果：boolean r1 =result1.get()

关闭服务：ser.shutdownNow();

推荐使用类实现Runnable接口，而不继承Thread类，因为java是单继承的。

线程的某些方法

休眠：sleep（参数：单位毫秒）

在线程执行时暂停一会。

礼让：yield（）

在多个线程执行时，允许别的线程与它争抢CPU资源

强制执行：join（）

在多个线程执行时，强制占用CPU资源

线程.currentThread.getName() 获得线程名

线程状态

NEW 尚未启动

RUNNABLE 正在运行

BLOCKED 等待锁的阻塞状态

WAITING 等待另一个线程执行特定动作

TIMED_WAITING 等待指定时间

TERMINATED 已经结束

线程.getState() 获得线程当前状态

线程优先级

MIN_PRIORITY = 1

MAX_PRIORITY = 10

NORM_PRIORITY = 5

用getPriority()获取进程优先级

用setPriority()改变进程优先级

守护(daemon)线程

虚拟机需要等待用户线程结束

不需要等待守护线程结束

当用户线程结束时，守护线程自己就结束了

线程.setDaemon(true)改变为守护线程，默认false为用户线程

线程同步机制

隐式锁

synchronized

方法一：synchronized方法

public synchronized void 方法名(参数){...}

该方***锁住当前对象this

方法二：synchronized代码块

synchronized(对象){代码块}

该方法可以锁任何变化的对象

显式锁

lock

用法：

private final ReentrantLock lock =new ReentrantLock();

run()方法里

try{

lock.lock();//加锁

...

}finally{

lock.unlock();//解锁

}

管程法、信号灯法

wait() 表示线程一直等待直到其他线程通知

wait(long timeout) 指定等待的毫秒数

notify() 唤醒一个处于等待状态的进程

notifyAll() 唤醒同一个对象上所有调用wait()方法的线程，优先级高的先调度

使用以上方法就是管程法

多加一个Boolen类型的标志位作为判断是否等待，就是信号灯法

线程池

用一个类似池子的东西存放一堆线程，避免线程重复创建和销毁。

ExecutorService：真正的线程池接口。常见子类ThreadPoolExecutor

void execute(Runnable command)：执行任务/命令，没有返回值，一般用来执行Runnable

<t>Future<t>submit(Callable<t> task)：执行任务，有返回值，一般用来执行Callable</t></t></t>

void shutdown()：关闭连接池

Executors：工具类、线程池的工厂类，用于创建并返回不同类型的线程池。

//创建服务，创建线程池

ExecutorService service = Executors.newFixedThreadPool(线程数)

//执行

service.execute(new MyThread());

service.execute(new MyThread());

service.execute(new MyThread());

//关闭连接

service.shutdown();

总结

//实现多线程
//1.继承Thread类
public class ThreadNew{
    public static void main (String[] args){
        new MyThread1().start();
        new Thread(new MyThread2()).start();
        FutureTask<Integer> futureTask = new FutureTask();
        new Thread(futureTask).start();
        try {
            Integer integer = futureTask.get();
            System.out.println(integer);
        }catch(InterruptedException e){
            e.printStackTrace();
        }catch(ExecutionException){
            e.printStackTrace();
        }
    }
}
class MyThread1 extends Thread{
    @Override
    public void run(){
        System.out.println("MyThread1");
    }
}
//2.实现Runnable接口
class MyThread2 implements Runnable{
    @Override
    public void run(){
        System.out.println("MyThread2");
    }
}
//3.实现Callable接口
class MyThread3 implements Callable<Integer>{
    @Override
    public Integer call() throws Exception{
        System.out.println("MyThread3");
        return 100;
    }
}