进程: 是一个正在执行中的程序
应用程序只要启动,就会在内存中分配一块内存空间(地址),进程其实就用于标示这个空间的,
用于封装里面那些控制单元
线程: 就是进程中的一个独立的控制单元。线程在控制着进程的执行。
线程是进程中的内容,每一个应用程序至少都有一个线程,因为线程是程序中的控制单元或者叫执行路径。
五个人同进搬东西,这五个人都在这一个进程中完成,每个人就是一个线程
Java VM 启动的时候会有一个进程java.exe. 该进程中至少一个线程负责java程序的执行。
而且这个线程运行的代码存在于main方法中. 该线程称之为主线程(主函数main)。
扩展:其实更细节说明jvm,jvm启动不止一个线程,还有负责垃圾回收机制的线程。
1,如何在自定义的代码中,自定义一个线程呢?
通过对api的查找(java核心包long),java已经提供了对线程这类事物的描述。就是Thread类。
【创建线程】的第一种方式:继承Thread类。
步骤:
1,定义类继承Thread。
2,覆写Thread类中的run方法。目的:将自定义代码存储在run方法。让线程运行。
3,调用线程的start方法, 该方法两个作用:启动线程(开启线程,并执行该线程的run方法)
运行过程:jvm开启主线程,主线程走着,碰到创建一个线程(新的控制单元),主线程就又开启了一个线程,
之后主线程和新线程都继续执行
程序运行结果每一次都不同:
因为多个线程都在获取cpu的执行权。谁获取到cpu的执行执行权,谁就运行。明确一点,在某一个时刻,只能有一个程序在运行。(多核除外),cpu在做着快速的切换,以达到看上去是同时运行的效果。我们可以形象的把多线程的运行行为在互相抢夺cpu的执行权。
这就是多线程的一个特性:随机性。谁抢到谁执行,至于执行多长,cpu说了算。
【为什么要覆盖run方法呢?】
Thread类用于描述线程。
该类就定义了一个功能,用于存储线程要运行的代码。该存储功能就是run方法。
也就是说Thread类中的run方法,用于存储线程要运行的代码。
主线程要执行的代码存在main方法中,这是jvm定义的,这就是jvm要调用main方法的原因
start()方法编译的时候走的是父类的方法,运行的时候走的是子类覆盖父类的run();
run()仅仅是封装线程要运行的代码
【线程状态】
创建、运行、冻结、临时、消亡,进程没了线程就挂了,因为空间没了
【获取线程对象及名称】
线程都有自己默认的名称。默认为:Thread-编号 该编号从0开始。
线程初始化时就可以超名称,父类把这事都做了,我们就直接用;
System.out.println((Thread.currentThread()==this)+"..."+this.getName()+" run..."+x);
Thread.currentThread()是标准通用方式,建议使用;static Thread currentThread():获取当前线程对象。
getName(): 获取线程名称。
设置线程名称:setName或者构造函数
线程1执行的时候,栈里面会给线程1分配一个空间;这里面有个独立的run方法,run方法里有个x(局部变量)
线程2执行的时候,栈里面会给线程2分配一个空间;这里面有个独立的run方法,run方法里有个x
Test t1 = new Test("one---"); new 一次就创建一个线程
Test t2 = new Test("two+++");
【卖票】
一般我们不定义静态,生命周期太长 private static tick = 100;
Runnabe接口【】(真正创建线程的是Thread类或它的子类)
创建线程的第二种方式:实现Runable接口
步骤:
1,定义类实现Runnable接口
2,覆盖Runnable接口中的run方法。
将线程要运行的代码存放在该run方法中。
3,通过Thread类建立线程对象。
4,将Runnable接口的子类对象作为实际参数传递给Thread类的构造函数。
为什么要将Runnable接口的子类对象传递给Thread的构造函数。
因为,自定义的run方法所属的对象是Runnable接口的子类对象。
所以要让线程去指定对象的run方法。就必须明确该run方法所属对象。
5,调用Thread类的start方法开启线程并调用Runnable接口子类的run方法。
实现方式和继承方式有什么区别呢?
实现方式好处:避免了单继承的局限性。
在定义线程时,建立使用实现方式。(共享资源)
两种方式区别:
继承Thread:线程代码存放Thread子类run方法中。
实现Runnable,线程代码存在接口的子类的run方法。 1秒=1000毫秒
run方法是接口的方法,接口没有抛异常,你抛就错,编译错误,所以处理异常不要抛
通过分析,发现,打印出0,-1,-2等错票。
【多线程的运行出现了安全问题】
问题的原因:
当多条语句在操作同一个线程共享数据时,一个线程对多条语句只执行了一部分,还没有执行完,
另一个线程参与进来执行。导致共享数据的错误。
解决办法:
对多条操作共享数据的语句,只能让一个线程都执行完。在执行过程中,其他线程不可以参与执行。
Java对于多线程的安全问题提供了专业的解决方式。
【就是同步代码块】
synchronized(对象) //对象 扔个obj吧(随便个对象) 就是说这对象有个标志位,标志位两值(0和1),默认为0(true),进来后先将0变成1,
{ 才执行下面代码,代码执行完后将标志位又变成0
需要被同步的代码
}
对象如同锁(锁旗标/监视器)。持有锁的线程可以在同步中执行。
没有持有锁的线程即使获取cpu的执行权,也进不去,因为没有获取锁。
火车上的卫生间---经典。
同步的前提:
1,必须要有两个或者两个以上的线程。2,必须是多个线程使用同一个锁。
3,访问同一资源(作为附加条件举例)
必须保证同步中只能有一个线程在运行。
同步代码块好处:解决了多线程的安全问题。弊端:多个线程需要判断锁,较为消耗资源,
【如何找问题】
1,明确哪些代码是多线程运行代码。run方法中的都是,2,明确共享数据。【b是,sum也是】
3,明确多线程运行代码中哪些语句是操作共享数据的.
函数是用来封装代码的,同步代码块也是用来封装代码的;
同步有两种表示形式:同步函数:封装代码 (不需要传对象);同步代码块:封装代码 (需要传对象)
【同步函数的锁是this】
把封装的部分单独写个同步函数封装下
同步函数用的是哪一个锁呢?函数需要被对象调用。那么函数都有一个所属对象引用。就是this。
所以同步函数使用的锁是this。
通过该程序进行验证。使用两个线程来买票。一个线程在同步代码块中。一个线程在同步函数中。都在执行买票动作。
【静态同步函数的锁是Class对象】
变量不加static在堆内存中是共享数据,加了static在方法区里是共享数据
如果同步函数被静态修饰后,使用的锁是什么呢?
通过验证,发现不在是this。因为静态方法中也不可以定义this。
静态进内存是,内存中没有本类对象,但是一定有该类对应的字节码文件对象。
类名.class 该对象的类型是Class
静态的同步方法,使用的锁是该方法所在类的字节码文件对象。 类名.class
【死锁】
同步中嵌套同步 (同步函数有同步代码块,同步代码块有同步函数)
【线程间通信】
就是多个线程在操作同一个资源,但是操作的动作不同。
线程运行的时候内存中会建立一个线程池,等待线程都存在线程池当中,notify();唤醒的都是线程池中的线程,
通常唤醒第一个等待的;
notifyAll();唤醒线程池中的所有线程,那个执行由cpu随机分配喽
wait notify() notifyAll()方法必须用在同步里面,因为要对持有锁的线程操作,而同步里的线程拥有锁,
用它们的时候必须标示出当前线程拥用的锁,因位同步会出现嵌套,会有两个锁
为什么这些操作线程的方法要定义Object类中呢?
因为这些方法在操作同步中线程时,都必须要标识它们所操作线程持有的锁,
只有同一个锁上的被等待线程,可以被同一个锁上notify唤醒。不可以对不同锁中的线程进行唤醒。
也就是说,等待和唤醒必须是同一个锁。
而锁可以是任意对象,所以可以被任意对象调用的方法定义Object类中。
【多生产者消费者】
if判断一次,这去之后就不在判断了,while判断多次,每次都要先判断;没判断标记;唤醒全部notifyAll();
对于多个生产者和消费者。为什么要定义while判断标记。原因:让被唤醒的线程再一次判断标记。
为什么定义notifyAll,因为需要唤醒对方线程。因为只用notify,容易出现只唤醒本方线程的情况。导致程序中的所有线程都等待。
【JDK1.5 中提供了多线程升级解决方案】
将同步Synchronized替换成现实Lock操作。
以前同步中只能有一个锁,1.5后可以有多个锁(可以帮定好几个Condition对象);
以前锁一嵌套就死锁,而1.5解决了多线程中的问题
1.5之后提供了显示的锁机制以及显示的锁对象上的等待、唤醒操作机制
释放锁的动作一定要执行
将Object中的wait,notify notifyAll,替换了Condition对象。该对象可以Lock锁 进行获取。
该示例中,实现了本方只唤醒对方操作。
Lock:替代了Synchronized
lock
unlock
newCondition()
Condition:替代了Object wait notify notifyAll
await();
signal();
signalAll();
【停止线程】
stop方法已经过时。如何停止线程?只有一种,run方法结束。
开启多线程运行,运行代码通常是循环结构。
只要控制住循环,就可以让run方法结束,也就是线程结束。
特殊情况:当线程处于了冻结状态(中断状态)。就不会读取到标记。那么线程就不会结束。
当没有指定的方式让冻结的线程恢复到运行状态是,这时需要对冻结进行清除。
强制让线程恢复到运行状态中来。这样就可以操作标记让线程结束。
Thread类提供该方法 interrupt();
【守护线程(后台线程)】
t1.setDaemon(true);t2.setDaemon(true);t1.start();t2.start();
后台线程特点:开启后和前台线程共同抢cpu执行权运行,开启运行都没区别,就结束有区别,不所有的前台线程都结束后,后台线程会自动结束 ;主线程是前台线程,主线程一结束,这两线程自动结束
【join】
t1.start();t1.join();t2.start();
t1.join();t1要cpu执行权(); t1要申请加入到运行中来,
主线程就处于冻结状态,t1线程执行完后,主线程才恢复到运行状态中来,
如果t1冻结或挂了,主线程就挂那了,这个时候 interrupt();清除状态
t1.start();t2.start();t1.join();
主线程释放执行权,t1和t2谁获得执行权主线程不管,主线程只等t1结束就会恢复到运行状态
谁让主线程释放执行权主线程就等谁执行完,join可以用来临时加入线程执行
【线程优先级】
一般性情下谁开启线程的,线程就属于那个组;如主线程开启t1线程的,t1就属于主线程main组
如果不想在这个组,可以建个组加进去ThreadGroup,比较少用
优先级:代表着抢资源(cpu)的频率
所有线程默认优先级都是5;优先级一共就1-10级,10最高了,
1 5 10最明显:10:MAX_PRIORITY 1:MIN_PRIORITY 5:NORM_PRIORITY
t1.setPriority(MAX_PRIORITY);设置优先级
【yield方法】
Thread.yiels();临时释放用的;执行到yield就翻译执行权
public void run()
{
for(int x=0; x<70; x++)
{
System.out.println(Thread.currentThread().toString()+"....."+x);
Thread.yield();
}
}
【什么时候用线程?】
当某些代码需要同时被执行时就用单独的线程进行封装;如匿名内部类
两种方式择一即可:
1: new Thread()
{
public void run()
{
for(int x=0; x<100; x++)
{
System.out.println(Thread.currentThread().getName()+"....."+x);
}
}
}.start();
2: Runnable r = new Runnable()
{
public void run()
{
for(int x=0; x<100; x++)
{
System.out.println(Thread.currentThread().getName()+"....."+x);
}
}
};
new Thread(r).start();