1.进程和线程的区别
进程:是一个正在执行中的程序。每一个进程执行都有一个执行顺序。该顺序是一个执行路径,或者叫一个控制单元。线程:就是进程中的一个独立的控制单元。线程在控制着进程的执行。一个进程中至少有一个线程。
2.创建线程的第一种方式:
继承Thread类。
步骤:
步骤:
1,定义类继承Thread。2,复写Thread类中的run方法。目的:将自定义代码存储在run方法。让线程运行。3,调用线程的start方法,
该方法两个作用:启动线程,调用run方法。
class Test extends Thread
{
public void run()//复写Thread类中的run方法
{
for (int a = 0;a<9 ;a++ )
{
System.out.println("线程第"+a+"次运行");
}
}
}
class ThreadDemo
{
public static void main(String[] args)
{
Test t = new Test();
t.start();//启动线程,调用run方法
for (int b =0;b<=9 ;b++ )//主线程运行的部分
{
System.out.println("主线程第"+b+"次运行");
}
}
}
实现Runable接口
步骤:
1,定义类实现Runnable接口
2,覆盖Runnable接口中的run方法。
将线程要运行的代码存放在该run方法中。
3,通过Thread类建立线程对象。
4,将Runnable接口的子类对象作为实际参数传递给Thread类的构造函数。
步骤:
1,定义类实现Runnable接口
2,覆盖Runnable接口中的run方法。
将线程要运行的代码存放在该run方法中。
3,通过Thread类建立线程对象。
4,将Runnable接口的子类对象作为实际参数传递给Thread类的构造函数。
5,调用Thread类的start方法开启线程并调用Runnable接口子类的run方法。
为什么要将Runnable接口的子类对象传递给Thread的构造函数。
因为,自定义的run方法所属的对象是Runnable接口的子类对象。
所以要让线程去执行指定对象的run方法。就必须明确该run方法所属对象。
代码示例:
class Test implements Runnable
{
public void run()
{
for (int a = 0;a<9 ;a++ )
{
System.out.println("线程第"+a+"次运行");
}
}
}
class RunnableDemo
{
public static void main(String[] args)
{
Test t = new Test();
Thread th = new Thread(t);//将run方法所属的对象作为参数传入Thread对象中
th.start();
}
}
实现方式和继承方式有什么区别呢?
实现方式好处:避免了单继承的局限性。在定义线程时,建议使用实现方式。
两种方式区别:
继承Thread:线程代码存放Thread子类run方法中。实现Runnable:线程代码存在接口的子类的run方法。
线程每次运行的结果都不同的原因:
因为多个线程都想获取cpu的执行权。cpu执行到谁,谁就运行。在某一个时刻,只能有一个程序在运行。(多核除外)cpu在做着快速的切换,以达到看上去是同时运行的效果。我们可以形象把多线程的运行行为在互相抢夺cpu的执行权。
多线程的特性:随机性。谁抢到谁执行,至于执行多长,cpu说的算。
为什么要覆盖run方法呢?
Thread类用于描述线程。
该类就定义了一个功能,用于存储线程要运行的代码。该存储功能就是run方法。
也就是说Thread类中的run方法,用于存储线程要运行的代码。
Thread类用于描述线程。
该类就定义了一个功能,用于存储线程要运行的代码。该存储功能就是run方法。
也就是说Thread类中的run方法,用于存储线程要运行的代码。
3.线程的运行状态
线程执行状态说明:(一定要能自己分析)
1.当线程创建后,调用start()方法,启动线程;2.线程进入运行状态,但有时候,程序创建了多条线程,只会有一条线程能正常运行,其他线程虽然具备执行资格,但是没有执行权,此时这些线程就会进入阻塞状态;3.当线程同时具备执行资格和执行权时,才会正常运行;4.线程在运行过程中,被要求睡眠(sleep())或者等待(wait()),那么此线程将进入冻结状态5.当线程睡眠时间到了,或者等待线程被唤醒,那么被冻结的线程将有可能会直接进入运行状态,也有可能进入阻塞状态6.线程正常运行时,如果遇到stop()方法或者run()方法call()方法执行完毕,线程就会死亡。
阻塞状态的特点:
拥有执行资格,没有执行权。CPU赋予线程执行权时,线程才能进入运行状态
冻结状态的特点:
线程放弃了执行资格,当线程拿到了执行资格时,不一定拥有执行权,就会进入阻塞状态当然,线程也可以在拿到了执行资格的同时,也拥有了执行权,此时线程直接进入运行状态。
多线程的安全问题。
多线程的随机性,cpu不断的切换造成的
问题的原因:
多线程的随机性,cpu不断的切换造成的
问题的原因:
当多条语句在操作同一个线程共享数据时,一个线程对多条语句只执行了一部分,还没有执行完,另一个线程参与进来执行。导致共享数据的错误。
解决办法:
对多条操作共享数据的语句,只能让一个线程都执行完。在执行过程中,其他线程不可以参与执行。Java对于多线程的安全问题提供了相应的解决方式—— 同步代码块。
格式:
synchronized(对象){需要被同步的代码}
对象如同锁。持有锁的线程可以在同步中执行。
没有持有锁的线程即使获取cpu的执行权,也进不去,因为没有获取锁。
必须保证同步中只能有一个线程在运行。
没有持有锁的线程即使获取cpu的执行权,也进不去,因为没有获取锁。
必须保证同步中只能有一个线程在运行。
同步的前提:
1,必须要有两个或者两个以上的线程。
2,必须是多个线程使用同一个锁。
同步的利与弊:
1,必须要有两个或者两个以上的线程。
2,必须是多个线程使用同一个锁。
同步的利与弊:
好处:解决了多线程的安全问题。
弊端:多个线程需要判断锁,较为消耗资源
弊端:多个线程需要判断锁,较为消耗资源
火车上的卫生间---经典。
火车上卫生间的门,带有红绿颜色标示的锁,当锁上显示红色说明里面有人,显示绿色说明里面没人。
当你去卫生间时,看到门锁上面显示绿色,那么说明里面没人,你就可以进去运行,那么别人再来就会看到门锁的颜色是红色的,就知道里面有人,来人将会在外面等待。当你运行完毕出来后,门锁变成绿色,等待的人看到门锁是绿色的就知道里面没人了,就会进去执行。
/**
窗口卖票
*/
class Tickets implements Runnable
{
private int a = 30;
public void run()
{
while (true)
{
synchronized(this)
{
if (a>0)
{
System.out.println(Thread.currentThread().getName()+"窗口卖票"+a--);
}
}
}
}
}
class SaleTicketDemo
{
public static void main(String[] args)
{
Tickets t = new Tickets();
Thread th1 = new Thread(t);
Thread th2 = new Thread(t);
th1.start();
th2.start();
}
}
同步函数用的是哪一个锁呢?
函数需要被对象调用。那么函数都有一个所属对象引用。就是this。所以同步函数使用的锁是this。
如果同步函数被静态修饰后,使用的锁是什么呢?
通过验证,发现不再是this。静态方法中也不可以定义this。静态进内存时,内存中没有本类对象,但是一定有该类对应的字节码文件对象。类名.class 该对象的类型是Class静态的同步方法,使用的锁是该方法所在类的字节码文件对象。 类名.class
代码示例:
/**
多个窗口卖票小程序
分析:
票是共享数据
窗口是线程
思路:
建立票的类
建立多个窗口线程
*/
class Ticket implements Runnable
{
private static int num = 100;
boolean pos = true;
public void run()
{
if (pos)
{
while (true)
{
synchronized(Ticket.class)
{
if (num>0)
{
System.out.println(Thread.currentThread().getName()+"窗口正在卖"+num--+"号票");
}
}
}
}else
{
while (true)
{
show();
}
}
}
public static synchronized void show()//静态同步方法使用的锁是所在类的字节码对象
{
if (num >0)
System.out.println(Thread.currentThread().getName()+"窗口正在卖"+num--+"号票");
}
}
class TicketDemo1
{
public static void main(String[] args)
{
Ticket t = new Ticket();
Thread th1 = new Thread(t);
Thread th2 = new Thread(t);
th1.setName("一号");
th2.setName("二号");
th1.start();
try{Thread.sleep(10);}catch(Exception e){}//调试阻塞情况
t.pos = false;
th2.start();
}
}
懒汉式:当调用了单例类中的方法时,程序才会创建对象,传说中的延时加载就是这么回事
懒汉式代码示例:
/**
单例设计模式
懒汉式
步骤:
构造函数私有
创建一个空对象
提供一个公共访问方法
*/
class Single
{
private Single(){}
private Single s= null;
public Single getSingle()
{
if (s == null)
{
synchronized(Single.class)
{
if (s ==null)
{
s = new Single();
}
}
}
}
}
同步嵌套同步会发生死锁——要避免此情况的发生
死锁案例:
/*
死锁。
同步中嵌套同步。
*/
class Ticket implements Runnable
{
private int tick = 1000;
Object obj = new Object();
boolean flag = true;
public void run()
{
if(flag)
{
while(true)
{
synchronized(obj)
{
show();
}
}
}
else
while(true)
show();
}
public synchronized void show()//同步函数嵌套同步代码块,此处发生死锁
{
synchronized(obj)
{
if(tick>0)
{
try{Thread.sleep(10);}catch(Exception e){}
System.out.println(Thread.currentThread().getName()+"....code : "+ tick--);
}
}
}
}
class DeadLockDemo
{
public static void main(String[] args)
{
Ticket t = new Ticket();
Thread t1 = new Thread(t);
Thread t2 = new Thread(t);
t1.start();
try{Thread.sleep(10);}catch(Exception e){}
t.flag = false;
t2.start();
}
}
static Thread currentThread():返回对当前正在执行的线程对象的引用。
String getName():返回该线程的名称