多线程
- **并行**：指两个或多个事件在**同一时刻**发生（同时执行）。
- **并发**：指两个或多个事件在**同一个时间段内**发生(交替执行)。
- **进程**：是指一个内存中运行的应用程序，每个进程都有一个独立的内存空间，一个应用程序可以同时运行多个进程；进程也是程序的一次执行过程，是系统运行程序的基本单位；系统运行一个程序即是一个进程从创建、运行到消亡的过程。
- **线程**：是进程中的一个执行单元，负责当前进程中程序的执行，一个进程中至少有一个线程。一个进程中是可以有多个线程的，这个应用程序也可以称之为多线程程序
- 进程：有独立的内存空间，进程中的数据存放空间（堆空间和栈空间）是独立的，至少有一个线程。
- 线程：堆空间是共享的，栈空间是独立的，线程消耗的资源比进程小的多。
> 1:因为一个进程中的多个线程是并发运行的，那么从微观角度看也是有先后顺序的，哪个线程执行完全取决于 CPU 的调度，程序员是干涉不了的。而这也就造成的多线程的随机性。
> 2:Java 程序的进程里面至少包含两个线程，主进程也就是 main()方法线程，另外一个是垃圾回收机制线程finalize（）。每当使用 java 命令执行一个类时，实际上都会启动一个 JVM，每一个 JVM 实际上就是在操作系统中启动了一个线程，java 本身具备了垃圾的收集机制，所以在 Java 运行时至少会启动两个线程。
> 3:由于创建一个线程的开销比创建一个进程的开销小的多，那么我们在开发多任务运行的时候，通常考虑创建多线程，而不是创建多进程。
**线程调度:**
- 分时调度
所有线程轮流使用 CPU 的使用权，平均分配每个线程占用 CPU 的时间。
- 抢占式调度
优先让优先级高的线程使用 CPU，如果线程的优先级相同，那么会随机选择一个(线程随机性)，Java使用的为抢占式调度。
构造方法：
- `public Thread()`:分配一个新的线程对象。
- `public Thread(String name)`:分配一个指定名字的新的线程对象。
- `public Thread(Runnable target)`:分配一个带有指定目标新的线程对象。
- `public Thread(Runnable target,String name)`:分配一个带有指定目标新的线程对象并指定名字。
常用方法：
- `public String getName()`:获取当前线程名称。
- `public void start()`:导致此线程开始执行; Java虚拟机调用此线程的run方法。
- `public void run()`:此线程要执行的任务在此处定义代码。
- `public static void sleep(long millis)`:使当前正在执行的线程以指定的毫秒数暂停（暂时停止执行）。
- `public static Thread currentThread() `:返回对当前正在执行的线程对象的引用。
Collections.synchronizedList(list); //线程安全
public final int getPriority()返回此线程的优先级。
public final void setPriority(int newPriority)更改此线程的优先级
1、线程默认优先级是5
2、线程优先级的范围是1-10
3、线程优先级高仅仅代表获取的CPU时间片的几率高，但是不是绝对会先获取
public static void main(String[] args) { Thread t1 = new PriorityDemo("小张"); Thread t2 = new PriorityDemo("小侯"); System.out.println(t1.getPriority()); //5 t2.setPriority(10); System.out.println(t2.getPriority()); //10 t1.start(); t2.start(); }
线程休眠
public static void sleep(long millis)
线程加入
public final void join() //先执行jion那个
线程礼让
public static void yield() //暂停当前正在执行的线程对象，并执行其他线程,但是它并不能保证一人一次
后台线程
public final void setDaemon(boolean on)
中断线程
public final void stop() 让线程停止，过时了，但是还能用
public void interrupt() 中断这个线程,并且抛出异常
JionDemo t1 = new JionDemo("小张"); JionDemo t2 = new JionDemo("小侯"); JionDemo t3 = new JionDemo("小刘"); t1.start(); try { t1.join(); //t1先执行完 } catch (InterruptedException e) { e.printStackTrace(); } t2.start(); t3.start();
@Override public void run() { for (int i=0;i<10;i++){ try { sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(getName()+","+i); } } }
public class ThreadStopDemo1 { public static void main(String[] args) { StopDemo t1 = new StopDemo("小张"); t1.start(); try { Thread.sleep(3000); t1.interrupt(); //java.lang.InterruptedException: sleep interrupted } catch (InterruptedException e) { e.printStackTrace(); } } } class StopDemo extends Thread{ StopDemo(String name){ super(name); } @Override public void run() { System.out.println("开始时间为"+new Date());//开始时间为Fri Aug 20 20:19:00 CST 2021 try { Thread.sleep(10000); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println("结束时间为"+new Date());//结束时间为Fri Aug 20 20:19:03 CST 2021 } }
public void run() { for (int i = 0; i < 10; i++) { System.out.println(getName() + ":" + i); Thread.yield(); } }
创建线程方式一_继承方式
1. 定义Thread类的子类，并重写该类的run()方法，该run()方法的方法体就代表了线程需要完成的任务,因此把run()方法称为线程执行体。
2. 创建Thread子类的实例，即创建了线程对象
3. 调用线程对象的start()方法来启动该线程
public class MyThreadDemo { public static void main(String[] args) { MyThread t1 = new MyThread("线程一"); t1.start(); new MyThread("线程二").start(); } } class MyThread extends Thread{ MyThread(String name){ super(name)； } @Override public void run() { for (int i=0;i<10;i++){ System.out.println(getName()+i+"次"); } } }
创建线程的方式二_实现方式
1. 定义Runnable接口的实现类，并重写该接口的run()方法，该run()方法的方法体同样是该线程的线程执行体。
2. 创建Runnable实现类的实例，并以此实例作为Thread的target来创建Thread对象，该Thread对象才是真正的线程对象。
3. 调用线程对象的start()方法来启动线程。
tips:Runnable对象仅仅作为Thread对象的target，Runnable实现类里包含的run()方法仅作为线程执行体。而实际的线程对象依然是Thread实例，只是该Thread线程负责执行其target的run()方法。
public class MyRunableDemo { public static void main(String[] args) { MyRunable m = new MyRunable(); Thread t1 = new Thread(m,"线程一"); Thread t2 = new Thread(m,"线程二"); t1.start(); t2.start(); } } class MyRunable implements Runnable{ @Override public void run() { for (int i=0;i<10;i++){ System.out.println(Thread.currentThread().getName()+i+"次"); } } }
**实现Runnable接口比继承Thread类所具有的优势：
1. 适合多个相同的程序代码的线程去共享同一个资源。
2. 可以避免java中的单继承的局限性。
3. 增加程序的健壮性，实现解耦操作，代码可以被多个线程共享，代码和线程独立。
4. 线程池只能放入实现Runable或Callable类线程
使用匿名内部类的方式实现Runnable接口，重新Runnable接口中的run方法：
public class NoNameDemo { public static void main(String[] args) { new Thread(new Runnable() { @Override public void run() { for (int i=0;i<10;i++){ System.out.println(Thread.currentThread().getName()+i+"次"); } } },"小张").start(); for (int i=0;i<10;i++) { System.out.println(Thread.currentThread().getName()+i+"次"); } } }
**同步代码块**：`synchronized`关键字可以用于方法中的某个区块中，表示只对这个区块的资源实行互斥访问。
格式:
synchronized(同步锁){
需要同步操作的代码
public class TickDemo1 { public static void main(String[] args) { Ticket1 t = new Ticket1(); new Thread(t,"窗口一").start(); new Thread(t,"窗口二").start(); new Thread(t,"窗口三").start(); } } class Ticket1 implements Runnable { private int ticket = 100; Object lock = new Object(); @Override public void run() { while (true) { synchronized (lock) { if (ticket > 0) { try { Thread.sleep(100); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(Thread.currentThread().getName() + "正在卖:" + ticket--); } } } } }
- **同步方法**:使用synchronized修饰的方法,就叫做同步方法,保证A线程执行该方法的时候,其他线程只能在方法外等着。
public synchronized void method(){
可能会产生线程安全问题的代码
}
> 同步锁是谁?
> 对于非static方法,同步锁就是this。
> 对于static方法,我们使用当前方法所在类的字节码对象(类名.class)。
class Ticket2 implements Runnable { private int ticket = 100; @Override public synchronized void run() { while (true) { if (ticket > 0) { try { Thread.sleep(100); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(Thread.currentThread().getName() + "正在卖:" + ticket--); } } } }
Lock锁也称同步锁，加锁与释放锁方法化了，如下：
- `public void lock() `:加同步锁。
- `public void unlock()`:释放同步锁。
class Ticket3 implements Runnable { private int ticket = 100; Lock lock=new ReentrantLock(); @Override public void run() { while (true) { lock.lock(); if (ticket > 0) { try { Thread.sleep(100); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(Thread.currentThread().getName() + "正在卖:" + ticket--); } lock.unlock(); } } }
死锁问题： 是指两个或者两个以上的线程在执行的过程中，因争夺资源产生的一种互相等待现象
public class DeadLock extends Thread{ public static Object LockA=new Object(); public static Object LockB=new Object(); private boolean flag; public DeadLock(boolean flag){ this.flag=flag; } @Override public void run() { if(flag){ synchronized (LockA){ System.out.println("LOCKA"); synchronized (LockB){ System.out.println("LOCKB"); } } } synchronized (LockB){ System.out.println("LOCKBB"); synchronized (LockA){ System.out.println("LOCKAA"); } } } } class DemoLock{ public static void main(String[] args) { DeadLock t1 = new DeadLock(true); DeadLock t2 = new DeadLock(false); t1.start(); t2.start(); } }
* Timer:定时
* Timer() 创建一个新的计时器。
* void schedule(TimerTask task, long delay) 在指定的延迟之后安排指定的任务执行。
* void schedule(TimerTask task, long delay, long period) 在指定的延迟之后开始 ，重新执行固定延迟执行的指定任务。
* void cancel() 终止此计时器，丢弃任何当前计划的任务。
* TimerTask:任务
public class TimerDemo { public static void main(String[] args) { Timer t = new Timer(); // t.schedule(new MyTime(),2000); t.schedule(new MyTime(),2000,4000); } } class MyTime extends TimerTask{ @Override public void run() { System.out.println("艺术就是爆炸"); } }
- **线程池：**其实就是一个容纳多个线程的容器，其中的线程可以反复使用，省去了频繁创建线程对象的操作，无需反复创建线程而消耗过多资源
使用线程池中线程对象的步骤：
1. 创建线程池对象。 - `public static ExecutorService newFixedThreadPool(int nThreads)`：返回线程池对象
2. 创建Runnable接口子类对象。(task)
3. 提交Runnable接口子类对象。(take task)
4. 关闭线程池(一般不做)。
public class ThreadPoolDemo2 { public static void main(String[] args) throws ExecutionException, InterruptedException { ExecutorService service= Executors.newFixedThreadPool(2); Callable<Double> c=new Callable<Double>() { @Override public Double call() throws Exception { return Math.random(); } }; System.out.println(service.submit(c).get()); System.out.println(service.submit(c).get()); System.out.println(service.submit(c).get()); System.out.println(service.submit(c).get()); } }
生产者消费者问题
public class Demo { public static void main(String[] args) { ArrayList<String> list = new ArrayList<>(); BaoZiPu bzp = new BaoZiPu(list); ChiHuo ch = new ChiHuo(list); bzp.start(); ch.start(); } } class BaoZiPu extends Thread { private ArrayList<String> list; BaoZiPu(ArrayList<String> list) { this.list=list; } @Override public void run() { int i = 0; while (true) { try { Thread.sleep(2000); } catch (InterruptedException e) { e.printStackTrace(); } synchronized (list) { if (list.size() > 0) { try { list.wait(); } catch (InterruptedException e) { e.printStackTrace(); } } list.add("包子" + i++); System.out.println(list); list.notify(); } } } } class ChiHuo extends Thread { private ArrayList<String> list; ChiHuo(ArrayList<String> list) { this.list = list; } @Override public void run() { while (true) { try { Thread.sleep(2000); } catch (InterruptedException e) { e.printStackTrace(); } synchronized (list) { if (list.size() == 0) { try { list.wait(); } catch (InterruptedException e) { e.printStackTrace(); } } list.remove(0); System.out.println("吃完了不够再来"); list.notify(); } } } }
