进程:正在运行的程序(直译)分配程序的内存空间
线程:就是进程中的一个负责程序执行的控制单元(执行路径)
一个进程中可以有多执行路径,称之为多线程
一个进程中至少有一个线程
开启多个线程是为了同时运行多个代码。
每一个线程都有自己的运行内容,这个内容可以称之为线程要执行的任务。
多线程的好处:解决了部分同时运行的问题
多线程的弊端:线程太多转换效率会低
其实应用程序的执行都是CPU在做着快速的切换完成的。这个切换是随机的。
JVM启动时就启动了多个线程,至少有两个线程可以解析出来。
1.执行main函数的线程
该线程的任务代码都定义在main函数中
2.负责垃圾回收的线程
如何创建一个线程:
方式一:继承Thread类
步骤:
- 定义一个类extend Thread类
- 覆盖Thread类中的run方法
- 直接创建Thread的子类的对象创建线程
- 调用start方法开启线程,让虚拟机调用该线程的run方法
start开启线程调用run方法
class Demo extends Thread
{
String name;
Demo(String name)
{
this.name=name;
}
public void show()
{
for(int x=1;x<10;x++)
{
for(int y=-9999999;y<99999999;y++){}
System.out.println("name is "+name+Thread.currentThread().getName());
}
}
public void run()
{
show();
}
}
class ThreadDemo
{
public static void main(String[] args)
{
Demo a=new Demo("周杰伦");
Demo b=new Demo("陈奕迅");
a.start();
b.start();
}
}
创建线程的目的是为了开启一条执行路径,取运行指定的代码和其他代码实现同时运行。
而运行的指定代码就是这个执行路径的任务。
JVM创建的主线程的任务都定义在了主函数中,而自定义的线程的任务在哪?
Thread类用于描述线程,线程是需要任务的。所以Thread的类也对任务有描述。
这个任务描述就是通过Thread类中的run方法来体现。也就是说,run方法是封装自定义线程运行任务的函数。
run方法定义的就是线程中要运行的任务代码。
开启线程是为了运行指定的代码,所以需要继承Thread类并复写run方法。
将运行的代码定义在run方法中即可。
可以通过Thread的getName()获取线程名称。THread-编号(从0开始)
通过Thread的getName()获取当前运行线程的名字
通过Thread的currentThread返回当前正在执行线程的引用。
多线程的状态
创建线程的第二种方式:实现Runnable
步骤:
- 定义实现Runnable接口;
- 覆盖接口中的run方法,将线程的任务代码封装到run方法中;
- 通过Thread类创建线程对象,并将Rnnable接口的子类对象作为Thread类的构造函数的参数进行传递。 why?因为线程的任务都封装在Runnable接口的子类对象的run方法中。所以要在线程对象创建时就必须明确要运行的任务。
- 调用线程对象的start方法开启线程。
class Demo2 implements Runnable
{
String name;
Demo(String name)
{
this.name=name;
}
public void show()
{
for(int x=1;x<10;x++)
{
for(int y=-9999999;y<99999999;y++){}
System.out.println("name is "+name+Thread.currentThread().getName());
}
}
public void run()
{
show();
}
}
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();
}
}
//Thread类的内部实现
class Thread{
private Runnable r;
Thread(){
//空参数
}
Thread(Runnable r){
this.r=r;
}
public void run(){
if(r!=null)
r.run();
}
public void start(){
run();
}
...
}
实现Runnable接口的好处:
- 将线程的任务从线程的子类中分离出来,进行单独的封装。按照面向对象的思想将任务封装成对象。
- 避免了java单独继承的局限性。所以,创建线程的第二种方法比较常用。
买票问题第一种实现:出现了四个ticket对象,导致变成400张票
解决方式之一是静态num。
class Ticket extends Thread
{
private static int num=100;
public void run(){
while(true){
if(num>0)
System.out.println(Thread.currentThread().getName()+"...num="+name);
}
}
}
class TicketTestDemo
{
public static void main(String[] args)
{
Ticket t1=new Ticket();
Ticket t2=new Ticket();
Ticket t3=new Ticket();
Ticket t4=new Ticket();
t1.start();
t2.start();
t3.start();
t4.start();
}
}
解决方式之二是使用Runnable接口。
class Ticket implements Runnable
{
private int num=100;
public void run(){
while(true){//隐患,线程安全问题
if(num>0)
System.out.println(Thread.currentThread().getName()+"...num="+name--);
}
}
}
class TicketTestDemo
{
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();
}
}
线程安全问题的产生:
1.多个线程在操作共享的数据
2.操作共享数据的线程代码有条。
当一个线程在执行操作共享数据的多条代码过程中,其他线程参与了运算。就会导致线程安全问题的产生。
解决思路:
就是将多条操作共享数据的线程代码封装起来,当有线程代码在执行这些代码的时候,其他线程是不可以参与运算的。
必须要当前线程把这些代码都执行完毕后,其他线程才可以参与运算。
在java中,用同步代码块就可以解决这个问题。
同步代码块的格式:
synchronized(对象)
{
需要被同步的代码块;
}
同步的好处:解决了线程安全问题
同步的弊端:相对降低了效率,因为同步外的线程都会判断同步锁。
同步的前提:同步中必须有多个线程并使用同一个锁。
class Ticket implements Runnable
{
Object obj=new Object();
private int num=100;
public void run()
{
while(true){
synchronized(obj)
{
if(num>0)
System.out.println(Thread.currentThread().getName()+"...num="+name--);
}
}
}
}
class TicketTestDemo
{
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个人到银行分别分三次存300块钱
class Bank
{
// private Object obj=new Object();
private int sum;
public synchronized void add(int num)//同步的第二种表现形式,同步代码块
{
// synchronized(obj){
sum=sum+num;
System.out.println(Thread.currentThread().getName()+"sum="+sum)
// }
}
}
class Consumer implements Runnable
{
Bank b=new Bank();
public void run()
{
for(int i=0;i<3;i++){
b.add(100);
}
}
}
class BankDemo
{
public static void main(String[] args)
{
Consumer c=new Consumer();
Thread t1=new Thread(c);
Thread t2=new Thread(c);
t1.start();
t2.start();
}
}
同步函数使用的锁是this:
同步函数和同步代码块的区别:同步函数的锁是固定的this,同步代码块的锁是任意的对象。
建议使用同步代码块。
class Ticket implements Runnable
{
// Object obj=new Object();
private int num=100;
private boolean flag=true;
public void run()
{
if(flag)
{
while(true){
synchronized(this)
{
if(num>0)
{
try{Thread.sleep(10);}catch(InterruptedException e){}
System.out.println(Thread.currentThread().getName()+"...num="+name--);
}
}
}else{
while(true)
{
this.show();
}
}
}
public synchronized void show(){
if(num>0){
try{Thread.sleep(10);}catch(InterruptedException e){}
System.out.println(Thread.currentThread().getName()+"...num="+name--);
}
}
}
class TicketTestDemo
{
public static void main(String[] args)
{
Ticket t=new Ticket();
Thread t1=new Thread(t);
Thread t2=new Thread(t);
t1.start();
t2.start();
}
}
静态的同步函数使用的锁是 该函数所属的字节码文件对象
可以使用getClass方法获取,也可使用当前的 类名.class表示
class Ticket implements Runnable
{
// Object obj=new Object();
private static int num=100;
private boolean flag=true;
public void run()
{
if(flag)
{
while(true){
synchronized(this.getClass())//Ticket.class
{
if(num>0)
{
try{Thread.sleep(10);}catch(InterruptedException e){}
System.out.println(Thread.currentThread().getName()+"...num="+name--);
}
}
}else{
while(true)
{
this.show();
}
}
}
public static synchronized void show(){
if(num>0){
try{Thread.sleep(10);}catch(InterruptedException e){}
System.out.println(Thread.currentThread().getName()+"...num="+name--);
}
}
}
class TicketTestDemo
{
public static void main(String[] args)
{
Ticket t=new Ticket();
Thread t1=new Thread(t);
Thread t2=new Thread(t);
t1.start();
t2.start();
}
}
死锁的一种情况:同步嵌
class MyLock//自定义锁对象
{
public static final Object locka=new Object();
public static final Object lockb=new Object();
}
class Demo
{
private boolean flag;
Demo(boolean flag){
this.flag=flag;
}
public void run(){
if(flag){
synchronized(MyLock.locka){
System.out.println(Thread.currentThread().getName()+"if locka run...");
synchronized(MyLock.lockb){
System.out.println(Thread.currentThread().getName()+"if lockb run...");
}
}
}else{
synchronized(MyLock.lockb){
System.out.println(Thread.currentThread().getName()+"else lockb run...");
synchronized(MyLock.locka){
System.out.println(Thread.currentThread().getName()+"else locka run...")
}
}
}
}
}
class DeadLock
{
public static void main(String[] args)
{
Demo d1=new Demo(true);
Demo d2=new Demo(false);
Thread t1=new Thread(d1);
Thread t2=new Thread(d2);
t1.start();
t2.start();
}
}