java学习——多线程
本文内容来源于 历经5年锤练--史上最适合初学者入门的Java基础视频
线程:就是进程中一个负责程序执行的控制单元(执行路径)
每一个线程都有自己运行的内容。这个内容可以称为线程要执行的任务。
多线程好处:解决了多部分同时运行的问题。
多线程的弊端:线程太多回到效率的降低。
JVM启动时就启动了多个线程,至少有两个线程可以分析的出来。
1,执行main函数的线程,
该线程的任务代码都定义在main函数中。
2,负责垃圾回收的线程。
多线程状态图:
如何创建一个线程呢?
创建线程方式一:继承Thread类。
步骤:
1,定义一个类继承Thread类。
2,覆盖Thread类中的run方法。
3,直接创建Thread的子类对象创建线程。
4,调用start方法开启线程并调用线程的任务run方法执行。
class Demo extends Thread{ ...... public void run(){ ...... } } class ThreadDemo2 { public static void main(String[] args) { Demo d1 = new Demo(); d1.start();//开启线程,调用run方法。 }
线程创建方式二:实现Runnable接口(比较常用)
步骤:
1,定义类实现Runnable接口。
2,覆盖接口中的run方法,将线程的任务代码封装到run方法中。
3,通过Thread类创建线程对象,并将Runnable接口的子类对象作为Thread类的构造函数的参数进行传递。
4,调用线程对象的start方法开启线程。
实现Runnable接口的好处:
1,将线程的任务从线程的子类中分离出来,进行了单独的封装。
按照面向对象的思想将任务的封装成对象。
2,避免了java单继承的局限性。
class Demo implements Runnable{ public void run(){ ... } } class ThreadDemo{ public static void main(String[] args) { Demo d = new Demo(); Thread t1 = new Thread(d); Thread t2 = new Thread(d); t1.start(); t2.start(); } }
小例子:卖票
线程安全问题产生的原因:
1,多个线程在操作共享的数据。
2,操作共享数据的线程代码有多条。
当一个线程在执行操作共享数据的多条代码过程中,其他线程参与了运算。
就会导致线程安全问题的产生。
解决思路;
就是将多条操作共享数据的线程代码封装起来,当有线程在执行这些代码的时候,
其他线程时不可以参与运算的,必须要当前线程把这些代码都执行完毕后,其他线程才可以参与运算。
在java中,用同步代码块就可以解决这个问题。
同步代码块的格式:
synchronized(对象)
{
需要被同步的代码 ;
}
同步的好处:解决了线程的安全问题。
同步的弊端:相对降低了效率,因为同步外的线程的都会判断同步锁。
同步的前提:同步中必须有多个线程并使用同一个锁。
class Ticket implements Runnable{ private int num = 100; Object obj = new Object(); public void run(){ while(true){ synchronized(obj){ //锁是任意的,可以使用this,即 synchronized(this) if(num>0){ try{Thread.sleep(10);}catch (InterruptedException e){} //睡一下便于发现是否有安全隐患
System.out.println(Thread.currentThread().getName()+".....sale...."+num--); } } } } } class TicketDemo{ public static void main(String[] args) { Ticket t = new Ticket();//创建一个线程任务对象。 Thread t1 = new Thread(t); Thread t2 = new Thread(t); Thread t3 = new Thread(t); Thread t4 = new Thread(t); t1.start(); t2.start(); t3.start(); t4.start(); } }
小例子2:储户,两个,每个都到银行(同一个银行)存钱每次存100,,共存三次。
涉及:同步函数
class Bank{ private int sum; public synchronized void add(int num)//同步函数:同步的第二种表现形式,锁是this { sum = sum + num; try{Thread.sleep(10);}catch(InterruptedException e){} System.out.println("sum="+sum); } } class Cus implements Runnable{ private Bank b = new Bank(); public void run(){ for(int x=0; x<3; x++){ b.add(100); } } } class BankDemo { public static void main(String[] args) { Cus c = new Cus(); Thread t1 = new Thread(c); Thread t2 = new Thread(c); t1.start(); t2.start(); } }
同步函数锁:
同步函数的使用的锁是this;
同步函数和同步代码块的区别:同步函数的锁是固定的this, 同步代码块的锁是任意的对象。
建议使用同步代码块。
静态的同步函数使用的锁是 该函数所属字节码文件对象
可以用 getClass方法获取,也可以用当前 类名.class 表示。
复习:单例设计模式
设计模式:对问题行之有效的解决方式。其实它是一种思想。
1,单例设计模式。
解决的问题:就是可以保证一个类在内存中的对象唯一性。
必须对于多个程序使用同一个配置信息对象时,就需要保证该对象的唯一性。
如何保证对象唯一性呢?
1,不允许其他程序用new创建该类对象。
2,在该类创建一个本类实例。
3,对外提供一个方法让其他程序可以获取该对象。
步骤:
1,私有化该类构造函数。
2,通过new在本类中创建一个本类对象。
3,定义一个公有的方法,将创建的对象返回。
//饿汉式(开发常用)
class Single//类一加载,对象就已经存在了。 { private static Single s = new Single(); private Single(){} public static Single getInstance() {return s;} }
//懒汉式(面试常用)有安全问题
class Single2//类加载进来,没有对象,只有调用了getInstance方法时,才会创建对象。延迟加载形式。 { private static Single2 s = null; private Single2(){} public static Single2 getInstance(){
if(s==null) s = new Single2(); return s;} }
多线程下的单例模式:
饿汉式没有安全问题,对懒汉式进行修改
加入同步为了解决多线程安全问题。
加入双重判断是为了解决效率问题。
class Single{ private static Single s = null; private Single(){} public static Single getInstance(){ if(s==null){//当s不为null时,则不进行锁的判断,直接返回s synchronized(Single.class){ if(s==null) // -->0 -->1 s = new Single(); } } return s; } }
死锁: 常见情景之一:同步的嵌套。
死锁同步嵌套Demo
线程间通讯:
多个线程在处理同一资源,但是任务却不同。
线程间通讯:等待唤醒机制
等待/唤醒机制。
涉及的方法:
1,wait(): 让线程处于冻结状态,被wait的线程会被存储到线程池中。
2,notify():唤醒线程池中一个线程(任意).
3,notifyAll():唤醒线程池中的所有线程。
这些方法都必须定义在同步中。
因为这些方法是用于操作线程状态的方法。
必须要明确到底操作的是哪个锁上的线程。
为什么操作线程的方法wait notify notifyAll定义在了Object类中?
因为这些方法是监视器的方法。监视器其实就是锁。
锁可以是任意的对象,任意的对象调用的方式一定定义在Object类中。
代码优化:
未完......