线程
1.概念
- 线程
- 程序运行时，即时没有自己创建线程，后台也会有多个线程，如主线程，gc线程
- main() 主线程，系统入口
- 多个线程运行由调度器安排调度
- 对于同一份资源，存在抢夺问题，需要加入并发控制
- 多线程带来额外开销，如CPU调度时间，并发控制开销
- 每个线程在自己的工作内存交互，内存控制不当会造成数据不一致
2.创建
-
继承Thread
-
自定义类继承Thread
-
重写run()
-
生成该类对象，调用start()
import org.apache.commons.io.FileUtils; import java.io.File; import java.io.IOException; import java.net.URL; public class TestThread extends Thread{ private String url; private String name; public TestThread(String url, String name){ this.url = url; this.name = name; } @Override public void run(){ WebDownloader downloader = new WebDownloader(); downloader.download(url,name); System.out.println("download complete:"+name); } public static void main(String[] args) { TestThread t1 = new TestThread("https://scpic.chinaz.net/files/pic/pic9/202105/bpic23171.jpg","1.jpg"); TestThread t2 = new TestThread("https://scpic.chinaz.net/files/pic/pic9/202105/bpic23172.jpg","2.jpg"); TestThread t3 = new TestThread("https://scpic.chinaz.net/files/pic/pic9/202105/bpic23173.jpg","3.jpg"); t1.start(); t2.start(); t3.start(); } } class WebDownloader{ public void download(String url,String name) { try { FileUtils.copyURLToFile(new URL(url),new File(name)); } catch (IOException e) { e.printStackTrace(); } } } -
-
实现Runnable
//可以避免单继承的局限性import java.util.Random; public class Race implements Runnable{ private int length; public Race(int length){ this.length = length; } @Override public void run() { Random rand = new Random(); for(int i=1;i<=length;i++){ //random sleep if((i%(rand.nextInt(10)+1))==10){ try { Thread.sleep(rand.nextInt(20)+1); } catch (InterruptedException e) { e.printStackTrace(); } } if(i%100==0) System.out.println(Thread.currentThread().getName()+" run "+i+" meters"); } System.out.println(Thread.currentThread().getName()+" complete!!!"); } public static void main(String[] args) { Race r = new Race(2000); Thread t1 = new Thread(r,"c1"); Thread t2 = new Thread(r,"c2"); Thread t3 = new Thread(r,"c3"); t1.start(); t2.start(); t3.start(); } } -
实现Callable
- 实现Callable接口，需要返回值类型
- 重写call方法，需要抛出异常
- 创建目标对象
- 创建执行服务：ExecutorService ser = Executors.newFixedThreadPool(1);
- 提交执行服务：Future<Boolean> result1 = ser.submit(t1);
- 获取结果：boolean r1 = result1.get();
- 关闭服务：ser.shutdownNow();
import java.util.concurrent.*; public class TestCallable implements Callable<Boolean> { private String url; private String name; public TestCallable(String url, String name){ this.url = url; this.name = name; } @Override public Boolean call(){ WebDownloader downloader = new WebDownloader(); downloader.download(url,name); System.out.println("download complete:"+name); return true; } public static void main(String[] args) throws ExecutionException, InterruptedException { TestCallable t1 = new TestCallable("https://scpic.chinaz.net/files/pic/pic9/202105/bpic23171.jpg","1.jpg"); TestCallable t2 = new TestCallable("https://scpic.chinaz.net/files/pic/pic9/202105/bpic23172.jpg","2.jpg"); TestCallable t3 = new TestCallable("https://scpic.chinaz.net/files/pic/pic9/202105/bpic23173.jpg","3.jpg"); //创建执行服务 ExecutorService ser = Executors.newFixedThreadPool(3); //提交执行 Future<Boolean> r1 = ser.submit(t1); Future<Boolean> r2 = ser.submit(t2); Future<Boolean> r3 = ser.submit(t3); //获取结果 boolean result1 = r1.get(); boolean result2 = r1.get(); boolean result3 = r1.get(); //关闭服务 ser.shutdownNow(); } }
3.线程状态
-
停止线程
//推荐自己让线程停止 /** *使用标识 */ class Test implements Runnable{ //1.标识 private boolean flag = true; @Override public void run(){ //2.线程主体使用该标识 wihle(flag){ //... } } //3.对外提供方法改变标识 public void stop(){ this.flag = false; } } -
线程休眠
- sleep(t) 阻塞 t毫秒
- sleep 存在异常 InterruptedException
- sleep时间达到后线程进入就绪态
- 每个对象都有一个锁，sleep不会释放锁
-
线程礼让
- 礼让线程，让当前正在执行的线程暂停，但不阻塞
- 将线程从运行态转为就绪态
- 让cpu重新调度
public class TestYield { public static void main(String[] args) { MyYield yield = new MyYield(); Thread t1 = new Thread(yield,"t1"); Thread t2 = new Thread(yield,"t2"); t1.start(); t2.start(); } } class MyYield implements Runnable{ @Override public void run() { System.out.println(Thread.currentThread().getName()+"开始执行"); Thread.yield(); System.out.println(Thread.currentThread().getName()+"执行结束"); } } -
join
- 父线程等待子线程执行结束
public class TestJoin { public static void main(String[] args) throws InterruptedException { Thread t = new Thread(()-> { for(int i=0;i<5;i++)System.out.println("t..."); }); t.start(); for(int i=0;i<40;i++){ if(i==10){ t.join(); //主线程（main）等待t线程执行结束再执行 } System.out.println("main..."); } } } -
观测线程状态
thread.getState();
-
线程优先级
thread.setPriority(int); thread.getPriority(); //先设置优先级，再启动 -
守护线程
- 线程分为用户线程和守护线程
- 虚拟机必须确保用户线程执行完毕
- 虚拟机不用等待守护线程执行完毕
- 如，后台记录操作日志，监控内存，垃圾回收
daemonThread.setDaemon(true);
4.线程同步
-
并发：同一个对象被多个线程同时操作
-
synchronized
- synchronized方法
- synchronized块
Java中每一个对象都可以作为锁，这是synchronized实现同步的基础：
普通同步方法（实例方法），锁是当前实例对象 ，进入同步代码前要获得当前实例的锁
静态同步方法，锁是当前类的class对象 ，进入同步代码前要获得当前类对象的锁
同步方法块，锁是括号里面的对象，对给定对象加锁，进入同步代码库前要获得给定对象的锁。 -
Lock
//ReentrantLock 可重入锁 import java.util.concurrent.locks.ReentrantLock; public class TestLock { public static void main(String[] args) { B b = new B(10); Thread t1 = new Thread(b); Thread t2 = new Thread(b); Thread t3 = new Thread(b); Thread t4 = new Thread(b); t1.start(); t2.start(); t3.start(); t4.start(); } } class B implements Runnable{ private int num; //lock private final ReentrantLock lock = new ReentrantLock(); public B(int num){ this.num = num; } @Override public void run(){ while(true){ // try{ lock.lock(); if(num>0){ try { Thread.sleep(100); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(Thread.currentThread().getName()+":"+(--num)); } else { break; } } finally { lock.unlock(); } } } }
5.线程协作
- 线程通信
- wait() 表示线程一直等待，直到其他线程通知，与sleep不同，wait()会释放锁
- wait(long timeout) 等待指定毫秒时间
- notify() 唤醒一个处于等待的线程
- notifyAll() 唤醒同一个对象上所有调用wait()方法的线程，优先级高的线程优先调度
//生产者消费者模型 利用缓冲区解决：管程法
public class TestPC {
public static void main(String[] args) {
SynContainer container = new SynContainer();
Producer producer = new Producer(container);
Consumer consumer = new Consumer(container);
producer.start();
consumer.start();
}
}
//生产者
class Producer extends Thread{
SynContainer container;
public Producer(SynContainer container){
this.container = container;
}
@Override
public void run(){
for(int i=0;i<100;i++){
System.out.println("Producer products "+i);
container.push(new Product(i));
}
}
}
//消费者
class Consumer extends Thread{
SynContainer container;
public Consumer(SynContainer container){
this.container = container;
}
@Override
public void run(){
for(int i=0;i<100;i++){
System.out.println("Consumer consumed "+i);
container.pop();
}
}
}
//产品
class Product extends Thread{
int id;
public Product(int id){
this.id = id;
}
}
//缓冲区
class SynContainer{
Product[] products = new Product[10];
int i=0;
public synchronized void push(Product product){
if(i==products.length){
//通知消费者，生产等待
try {
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
products[i] = product;
i++;
//通知消费者
this.notifyAll();
}
public synchronized Product pop(){
if(i==0){
//等待生产者生产，消费等待
try {
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
i--;
Product p = products[i];
//通知生产
this.notifyAll();
return p;
}
}
-
线程池
- ExecutorService：真正的线程池接口，常见子类ThreadPoolExecutor
- void execute(Runnable command)
- <T> Future<T> submit(Callable<T> task)
- void shutdown()
- Executors：工具类，线程池的工厂类，用于创建并返回不同类型的线程池
import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; public class TestPool { public static void main(String[] args) { //1.创建服务，创建线程池 ExecutorService service = Executors.newFixedThreadPool(10); //2.执行 service.execute(new MyThread()); service.execute(new MyThread()); service.execute(new MyThread()); service.execute(new MyThread()); //3.关闭 service.shutdownNow(); } } class MyThread extends Thread{ @Override public void run(){ System.out.println(this.getName()); } } - ExecutorService：真正的线程池接口，常见子类ThreadPoolExecutor
附1.静态代理模式
Thread 中的静态代理
Thread类实现了Runable接口，有一个成员变量 Runnable target
其实现的Runaable的run方法
@Override
public void run() {
if (target != null) {
target.run();
}
}
真实对象由用户定义生成，Thread代理完成线程相关工作，并执行真实对象run方法
理解：将任务的重复部分交给代理对象，任务的可变部分由用户实现，代理对象将重复部分和用户(target)定义的任务组成一个完整的任务，执行。
public class StaticProxy {
public static void main(String[] args) {
NetworkProxy proxy = new NetworkProxy(new Computer());
proxy.send();
}
}
//真实目标类和代理类需要共同实现的接口
interface SendData{
void send();
}
//真实目标类
class Computer implements SendData{
@Override
public void send() {
System.out.println("sending data:hello");
}
}
//代理类
class NetworkProxy implements SendData{
//真实目标对象
private SendData target;
public NetworkProxy(SendData target){
this.target = target;
}
@Override
public void send() {
before();
this.target.send(); //调用目标角色方法
after();
}
private void before(){
System.out.println("building connection...");
}
private void after(){
System.out.println("release connection!!!");
}
}
附2.Lamda表达式
- 函数式接口
- 任何接口，如果只包含唯一一个抽象对象，那么他就是一个函数式接口
- 对于函数式接口，可以通过Lamda表达式创建该接口的对象
- 函数式编程
- (params) -> expression
- (params) -> statement
- (params) -> {statements}
638
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
