1.Java多线程实现的三种方式
前言：普通方法调用 和 子线程方法调用区别
继承java.lang.Thread类(它实现了Runnable接口)
- 自定义线程类继承Thread类
- 重写run方法，编写线程执行体
- 创建线程对象，调用start()方法启动线程
不建议使用：避免OOP单继承局限性
实现Runnable接口
- 实现接口iRunnable具有多线程能力
- 启动线程：传入目标对象+Thread对象.start()
- 推荐使用：避免单继承局限性，灵活方便，方便同一个对象被多个线程使用
实现Callable接口
- 实现callable接口，需要返回值类型
- 重写call方法，需要抛出异常
- 创建目标对象
- 创建执行服务：ExecutionService ser=Executors.newFixedThreadPool(1);
- 提交执行：Future<boolean> result1=ser.submit(t1);</boolean>
- 获取结果：Boolean r1=result1.get();
- 关闭服务：ser.shutdownNow();
2.认识多线程带来问题
使用例子说明：买火车票
package snow.dong.multithreading;
//发现问题：多个线程同时操作同一个对象（或者统一资源）时候，线程不安全
public class TestThread1 implements Runnable{
//票数
private int ticketNums =10;
@Override
public void run() {
while(true){
if(ticketNums <= 0){
break;
}
try {
Thread.sleep(200);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+"----->拿到了第"+ticketNums--+"票");
}
}
public static void main(String[] args) {
TestThread1 ticket=new TestThread1();
new Thread(ticket,"张三").start();
new Thread(ticket,"王五").start();
new Thread(ticket,"黄牛").start();
}
} 结果: 没加锁，会出现负数 和 重复数
张三----->拿到了第8票 王五----->拿到了第10票 黄牛----->拿到了第9票 黄牛----->拿到了第7票 张三----->拿到了第5票 王五----->拿到了第6票 王五----->拿到了第4票 张三----->拿到了第4票 黄牛----->拿到了第3票 张三----->拿到了第2票 王五----->拿到了第1票 黄牛----->拿到了第0票 张三----->拿到了第-1票
3. 线程的周期
停止线程
- 不推荐使用JDK提供的stop(),destory()方法（已废弃）
- 推荐线程自己停下来
- 建议使用一个标志位，进行终止变量，当flag=false时，则终止线程运行
package snow.dong.multithreading; public class threadStop implements Runnable{ //1.线程中定义线程体使用的标识 private boolean flag= true; @Override public void run() { //2.线程体使用该标识 while(flag){ System.out.println("run ... Thread"); } } //3.对外提供方法，改变标识 public void stop(){ this.flag=false; } }
线程睡眠
- sleep(time)指定当前线程阻塞的毫秒数
- sleep方法存在一场InterruptedExecution
- sleep时间达到后线程进入就绪状态
- sleep可以模拟网络延迟，倒计时等
- 每个对象都有一个锁，sleep不会释放锁
package snow.dong.multithreading; import java.text.SimpleDateFormat; import java.util.Date; //打印时间 public class threadSleep { public static void main(String[] args) throws InterruptedException { //获取系统当前时间 Date startTime=new Date(System.currentTimeMillis()); while(true){ Thread.sleep(1000); System.out.println(new SimpleDateFormat("HH:mm:ss").format(startTime)); //更新当前时间 startTime=new Date(System.currentTimeMillis()); } } }
线程礼让
- 礼让线程，让当前正在执行的线程暂停，但不阻塞
- 让线程从运行状态转为就绪状态
- 让cpu从新调度，礼让不一定成功，看cpu调度
正在执行的线程，转为就绪状态从新等cpu的调度，肯能会被再次调度执行
package snow.dong.multithreading; public class threadYield { public static void main(String[] args) { MyYield myYield=new MyYield(); new Thread(myYield,"a").start(); new Thread(myYield,"b").start(); } } class MyYield implements Runnable{ @Override public void run() { System.out.println(Thread.currentThread().getName()+"线程开始执行"); Thread.yield(); System.out.println(Thread.currentThread().getName()+"线程停止执行"); } }线程强制执行join
Jion合并线程，待此线程执行完成后，再执行其他线程，其他线程阻塞
可能理解成插队
刚开始主线程和子线程并发执行，thread.join();后VIP线程（子线程）强制执行完
package snow.dong.multithreading; public class threadJoin implements Runnable{ @Override public void run() { for (int i = 0; i < 40; i++) { System.out.println("线程VIP来了"+i); } } public static void main(String[] args) throws InterruptedException { //启动我们的线程 threadJoin threadjoin=new threadJoin(); Thread thread=new Thread(threadjoin); thread.start(); //主线程 for (int i = 0; i < 100; i++) { if(i==50) thread.join(); System.out.println("主线程执行"+i); } } }
线程状态观测
- 新建，就绪，运行，阻塞，死亡
package snow.dong.multithreading; public class ThreadState { //主线程观察子线程状态，子线程run方法跑完后子线程终止，主线程跳出循环 public static void main(String[] args) throws InterruptedException { //创建一个子线程，运行lamda表达式 Thread thread=new Thread(()->{ for (int i = 0; i < 5; i++) { try { Thread.sleep(100); } catch (InterruptedException e) { e.printStackTrace(); } } System.out.println("////////////////////////"); }); //观察线程状态 Thread.State state=thread.getState(); System.out.println(state);//new //观察启动后 thread.start(); state=thread.getState(); System.out.println(state);//run //只要子线程不终止，就一致输出状态 while(state != Thread.State.TERMINATED){ Thread.sleep(100); state=thread.getState(); System.out.println(state); } } }
- 新建，就绪，运行，阻塞，死亡
线程优先级
- Java提供了一个线程调度器来监控程序中启动后进入就绪状态的所有线程，线程电镀漆按照优先级决定应该调度那个线程来执行
- 线程的优先级用数字表示，范围从0-10
- Thread.MIN_PRIORITY=1;
- Thread.MAX_PRIORITY=10;
- Thread.NORM_PRIORITY=5;
- 使用以下方式改变或获取优先级
-getPriority(),setPriority(int x) - 优先级低只是意味着获得调度的概率低，都看cpu调度
package snow.dong.multithreading; //测试线程优先级 public class ThreadPriority { public static void main(String[] args) { //主线程默认的优先级 System.out.println(Thread.currentThread().getName()+"-->"+Thread.currentThread().getPriority()); MyPriority myPriority=new MyPriority(); Thread t1=new Thread(myPriority,"Thread-a"); Thread t2=new Thread(myPriority,"Thread-b"); Thread t3=new Thread(myPriority,"Thread-c"); //先设置优先级，在启动 t1.start(); t2.setPriority(1); t2.start(); t3.setPriority(Thread.MAX_PRIORITY); t3.start(); } } class MyPriority implements Runnable{ @Override public void run() { System.out.println(Thread.currentThread().getName()+"-->"+Thread.currentThread().getPriority()); } }
守护线程
- 线程分为用户线程 和 守护线程
- 虚拟机必须确保用户线程执行完毕
- 虚拟机不必等待守护线程执行完毕
- 如，后台操作日志，监控内存，垃圾回收等待。。。
- 使用thread.setDaemon(true)设置为守护线程，默认false表示用户线程，正常的线程都是用户线程
4.线程同步机制
- 多个线程操作同一个资源
- 并发：同一个对象被多个线程在某一个时间段同时操作
- 由于同一个进程的多个线程共享同一块存储空间，在带来方便的同时，也带来了访问冲突问题，为了保证数据在方法中被访问时的正确性，在访问时加入锁机制 synchronized,当一个一个线程获得对象的排他锁，独占资源，其他线程必须等待。则出现以下问题：
- 一个线程持有锁会导致其他所有需要次锁的线程挂起
- 在多线程竞争下，加锁，释放锁会导致比较多的上下文切换 和 延迟调度，引起性能问题
- 如果一个优先级高的线程等待一个优先级低的线程释放锁，会导致优先级倒置，引起性能问题
- 针对方法使用synchronized，包括两种用法：synchronized方法 和 synchronized块
- synchronized方法控制对”对象“的访问，每个对象对应着一把锁，每个synchronized方法都必须获得调用该方法的对象的锁才能执行，否则线程阻塞，方法一旦执行，就独占该锁，直到该方法返回才释放锁，后面被阻塞的线程才能获得这个锁，继续执行。
- synchronized的缺点就是：若将一个大的方法声明为synchronized将会影响效率
- 同步块：synchronized(obj){}
- obj 称之为 同步监视器
- obj可以是任何对象，但是推荐使用共享资源作为同步监视器
- 同步方法中无需指定同步监视器，因为同步方法中的同步监视器就是this，就是这个对象本身，或者是class
- 同步监视器的执行过程：
- 1第一个线程访问，锁定同步监视器，执行其中代码
- 2第二个线程访问，发现同步监视器被锁定，无法访问
- 3第一个线程访问完毕，解锁同步监视器
- 4第二个线程访问，发现同步监视器没有锁，然后锁定并访问
某一个同步块 同时拥有”两个以上对象的锁”，就有可能发生死锁
进入同步块就拿到了锁，出了同步块就失去了锁
- obj 称之为 同步监视器
5.死锁
产生死锁的四个必要条件
- 互斥条件：一个资源每次只能被一个进程使用
- 请求与保持条件：一个进程因请求资源二阻塞时，对已获得资源保持不妨
- 不剥夺条件：进程已获得的资源，在未使用完毕之前，不能强行剥夺
- 循环等待条件：若干进程之间形成一种头尾相接的循环等待资源关系
只要破坏上面一个或者多个条件就能避免死锁发生
6.lock锁
- 从JDK5.0开始，Java提供了更强大的线程同步机制--通过显式定义同步锁对象来实现同步。同步锁使用lock对象充当
- java.util.concurrent.locks.Lock接口时控制多个线程对共享资源进行访问的工具。锁提供了对共享资源的独占访问，每次只能有一个线程对Lock对象加锁，线程开始访问共享资源之前应先获得Lock对象
- ReentrantLock类实现了Lock，它拥有与synchronized相同的并发性和内存语义，在实现线程安全的控制中，比较常用的时ReentrantLock,可以显式加锁，释放锁。
- synchronized 与 lock的对比
- lock时显式锁（手动开启和关闭锁），synchronized时隐式锁，出了作用域自动解锁
- lock锁只有代码块锁，synchronized有代码块和方法锁
- 使用lock锁，JVM将花费更小的时间来调度线程，性能更好，并且具有更好的高扩展性（提供了更多的子类）
- 优先使用顺序：
- lock > 同步代码块（已经进入了方法体，分配了相应的资源） > 同步方法（在方法体之外）
package snow.dong.multithreading; import java.util.concurrent.locks.ReentrantLock; //测试lock锁 public class TestLock { public static void main(String[] args) { TestLock2 testLock2=new TestLock2(); new Thread(testLock2,"a").start(); new Thread(testLock2,"b").start(); new Thread(testLock2,"c").start(); } } class TestLock2 implements Runnable{ int ticketNums =10; //定义lock锁 可重入锁 private final ReentrantLock lock=new ReentrantLock(); @Override public void run() { while(true){ try{ lock.lock();//加锁 if(ticketNums > 0) { try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(Thread.currentThread().getName()+"拿到了第"+ticketNums--+"张票"); }else { break; } }finally { lock.unlock();//枷锁 } } } }
7.使用线程池
- 背景：经常创建和销毁，使用量特别大的资源，比如并发情况下的线程，对性能的影响很大。
- 思路：提前创建好多个线程，放入线程池中，使用时直接获取，使用完后放回池中。可以避免频繁创建销毁，实现重复利用，类似公共交通工具。
- 好处：
- 提高响应速度（减少了创建新线程的时间）
- 降低资源消耗（重复使用线程池中的线程，不需要每次都创建）
- 便于线程管理（）
- corePoolsize:核心池的大小
- maximumPoolsize：最大线程数
- keepAliveTime:线程没有任务时最多保持多久时间后会终止
- Java5.0提供了线程池相关API：ExecutorService和Executors
- ExecutorService:真正的线程池接口。常用子类ThreadPoolExecutor
- void execute(Runnable command):执行任务/命令，没有返回值，一般用来执行Runnable
- <T> Future<T> submit(Callable<T> task):执行任务，有返回值，一般用来执行Callable
- void shudown():关闭连接池
- Executors：工具类，线程池的工厂类，用于创建并返回不同类型的线程池
1.使用void execute(Runnable command):执行任务/命令案例package snow.dong.multithreading; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; public class TestPool { public static void main(String[] args) { //1.创建服务，创建线程池 //newFixedThreadPool 参数为线程池大小 ExecutorService service= Executors.newFixedThreadPool(10); //执行 service.execute(new MyThread()); service.execute(new MyThread()); service.execute(new MyThread()); service.execute(new MyThread()); //关闭连接 service.shutdown(); /** * //新建三个任务 * TestCallable t1=new TestCallable(xx); * TestCallable t1=new TestCallable(xx); * TestCallable t1=new TestCallable(xx); * //创建执行服务 * ExecutorService service=Executors.newFixedThreadPool(3); * //提交执行 * Future<Boolean> r1=service.submit(t1); * Future<Boolean> r2=service.submit(t2); * Future<Boolean> r3=service.submit(t3); * //获取结果 * boolean rs1=r1.get(); * boolean rs2=r2.get(); * boolean rs3=r3.get(); * //打印结果 * System.out.println(rs1+rs2+rs3); * //关闭服务 * service.shutdown(); */ } } class MyThread implements Runnable{ @Override public void run() { System.out.println(Thread.currentThread().getName()); } }
8.总结
线程的三种实现方式
package snow.dong.multithreading;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
public class ThreadSum {
public static void main(String[] args) {
//第一个线程启动
new Mythread01().start();
//第二个线程启动
new Thread(new MyThread02()).start();
//第三个线程启动
FutureTask<Integer> futureTask=new FutureTask<Integer>(new MyThread03());
new Thread(futureTask).start();
try {
Integer integer=futureTask.get();
System.out.println(integer);
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}
}
}
//1.继承Thread类
class Mythread01 extends Thread{
@Override
public void run() {
System.out.println("Mythread01");
}
}
//2.实现Runnable接口
class MyThread02 implements Runnable{
@Override
public void run() {
System.out.println("MyThread02");
}
}
//3.实现callable接口
class MyThread03 implements Callable<Integer>{
@Override
public Integer call() throws Exception {
System.out.println("MyThread03");
return 103;
}
} 
京公网安备 11010502036488号