java基础 线程
参考详细：Java之多线程
一、创建线程
创建线程常见有两种方式，另外有两种新增方式
1.Thread
/**
新建线程方式一：继承Thread，重写run()
*/
public static void test1(){
Thread1 thread1 = new Thread1();
thread1.setName("thread1");
thread1.start();
}
static class Thread1 extends Thread{
int i;
@Override
public void run() {
while (i < 100){
++i;
System.out.println(this.getName() + " 优先级 "+this.getPriority()+"：" + i);
}
}
}
2.Runnable
/**
* 新建线程方式二：实现Runnable，实现run()；将Runnable作为Thread创建的实参
*/
public static void test2(){
Runnable runnable = new Runnable() {
int i;
@Override
public void run() {
while (i < 100){
++i;
System.out.println(Thread.currentThread().getName() + " 优先级 "+Thread.currentThread().getPriority()+"：" + i);
}
}
};
Thread thread2 = new Thread(runnable,"thread2");
thread2.start();
}
3.Callable --- JDK5.0新增
/**
* 新增·方式三：实现Callable接口，此功能支持有泛型返回值，支持抛出异常，需借助FutureTask类
*/
public static void test3() throws ExecutionException, InterruptedException {
Callable callable = getCallable();
FutureTask futureTask = new FutureTask<>(callable);
Thread thread3 = new Thread(futureTask);
thread3.start();
// 返回值
Integer integer = futureTask.get();
System.out.println("方式三：main获得结果-"+integer);
}
private static Callable getCallable(){
Callable callable = new Callable() {
int i;
@Override
public Integer call() throws Exception {
while (i < 100){
++i;
System.out.println(Thread.currentThread().getName() + " 优先级 "+Thread.currentThread().getPriority()+"：" + i);
}
return i;
}
};
return callable;
}
4.ThreadPool --- JDK5.0新增
/**
* 新增·方式四：使用线程池创建线程
*/
public static void test4() throws ExecutionException, InterruptedException {
ExecutorService service = Executors.newFixedThreadPool(5);
ThreadPoolExecutor service1 = (ThreadPoolExecutor)service;
Callable callable = getCallable();
Future future = service1.submit(callable);
System.out.println("方式四：main获得结果-"+future.get());
service.shutdown();
}
private static Callable getCallable(){
Callable callable = new Callable() {
int i;
@Override
public Integer call() throws Exception {
while (i < 100){
++i;
System.out.println(Thread.currentThread().getName() + " 优先级 "+Thread.currentThread().getPriority()+"：" + i);
}
return i;
}
};
return callable;
}
步骤：
1）提供指定线程池
ExecutorService service = Executors.newXXXThreadPool()
设置线程池属性
ThreadPoolExecutor service1 = ()service;
service1.setXXX
2）执行指定线程的操作，需要提供实现Runnable接口或Callable接口库实现类的对象
service.execute(xxx); // xxx为实现Runnable接口的类的对象
service.submit(xxx); // xxx为实现Callable接口的类的对象，返回结果Future类
3）关闭连接池
service.shutdown();
二、线程属性方法
1.Thread类的有关方法
1）start()：启动当前线程，调用当前线程的run()
2）run()：通常需要重写Thread类中的此方法，将创建的线程需要处理的逻辑写在这里
3）currentThread()：静态方法，返回执行当前代码的线程 this = Thread.currentThread()
4）getName()：获得当前线程的名字
5）setName()：设置当前线程的名字
6）yield()：释放当前cpu的执行权
7）join()：在线程a中调用线程b的join()，此时线程a就进入阻塞状态，直到线程b完全执行完成以后，线程a就是阻塞状态
8）stop()：已过时。当执行此方法，强制结束当前线程
9）sleep(long millitime)：让当前线程“睡眠”指定millitime毫秒。在指定的毫秒内，当前线程阻塞状态。
10）isAlive()：判断当前线程是否存活
2.线程优先级
1）等级：
MAX_PRIORITY：10，MIN_PRIORITY：1，NORM_PRIORITY：5
2）如何获取和设置当前线程优先级
getPriority()：获取当前线程优先级
setProority(int p)：设置当前线程优先级
高优先级线程要抢占低优先级线程cpu执行权。但是只是从概率上讲。
3.生命周期
yield()
- yield() 让当前正在运行的线程回到可运行状态，以允许具有相同优先级的其他线程获得运行的机会。因此，使用yield()的目的是让具有相同优先级的线程之间能够适当的轮换执行。但是，实际中无法保证yield()达到让步的目的，因为，让步的线程可能被线程调度程序再次选中
4.线程通信
方法
1）wait()：使得调用wait()的线程进入阻塞状态，并释放同步监视器
2）notify()：一旦执行此方法，就会唤醒被wait的一个线程。如果多个线程被wait，唤醒优先级高的
3）notifyAll()：一旦执行此方法，就会唤醒被wait的所有线程
说明
1）wait()，notiry()，notiryAll()需要声明在同步代码块或者同步代码方法中
2）wait()，notiry()，notiryAll()调用者必须是同步代码块或者同步代码方法的同步监视器，否则会出现异常
3）wait()，notiry()，notiryAll()声明在java.lang.Object当中
sleep() VS wait()
- sleep() 方法是线程类（Thread）的静态方法，调用此方法让当前线程暂停执行指定的时间，将执行机会（CPU）让给其他线程，但是对象的锁依然保持，因此休眠时间结束后会自动恢复（线程回到就绪状态）
- wait() 是Object类的方法，调用对象的wait()方法导致当前线程放弃对象的锁（线程暂停执行），进入对象的等待池（wait pool），只有调用对象的notify()方法（或notifyAll()方法）时才能唤醒等待池中的线程进入等锁池（lock pool），如果线程重新获得对象的锁就可以进入就绪状态
总结
- 不同：sleep()锁在，wait()锁不在。sleep()时间结束自动恢复；wait()等待notify()（或notifyAll()方法）唤醒
- 同：调用方法进入阻塞状态
三、线程同步机制
1.同步代码块
synchronized(同步监视器){
//需要同步的代码
}
同步监视器：类的对象
要求：多个线程必须要共用同一把锁，可以考虑使用this，类.class等
2.同步方法
将synchronized添加到方法
synchronized method()：同步监视器是this
static synchronized method()：同步监视器是类.class
3.Lock锁 --- JDK5.0新增
- 从JDK 5.0开始，Java提供了更强大的线程同步机制--通过显式定义同步锁对象来实现同步。同步锁使用Lock对象充当。
- java.util.concurrent.locks.Lock接口是控制多个线程对共享资源进行访问的工具。锁提供了对共享资源的独占访问，每次只能有一个线程对Lock对象加锁，线程开始访问共享资源之前应先获得Lock对象。
- ReentrantLock类实现了Lock，它拥有与 synchronized相同的并发性和内存语义，在实现线程安全的控制中，比较常用的是 Reentrantlock，可以显式加锁、释放锁
class A {
//1.实例化ReentrantLock对象
private final ReenTrantLock lock = new ReenTrantLook();
public void m (){
lock.lock//2.先加锁
try{
//保证线程同步的代码
}finally{
lock.unlock();//3.后解锁
}
}
}
//注意：如果同步代码块有异常，要将unlock()写入finally语句块中