Java基础 线程入门

Java基础 线程

线程的概述

进程 正在运行的程序 负责这个程序的内存空间分配 代表内存中的执行区域

线程 就是在一个进程中负责一个执行路径

多线程 就是在一个进程中多个路径同时执行(例如杀毒软件同时在做系统优化和垃圾清理)

自定义线程方式（一）

一种方式是将该类声明为Thread子类

(1) 该子类重写Thread的run方法 将自定义线程的任务代码放到run方法中

(2) 创建自定义线程对象 调用start方法 线程开启后调用到run方法

（不能直接调用run方法 只有调用start方法才算开启一个线程）

public class Demo extends Thread {
	@Override
	public void run() {
		for(int i=0;i<100;i++) {
			System.out.println("自定义线程"+i);
		}
	}
	public static void main(String[] args) {
		Demo d=new Demo();
		d.start();
		for(int i=0;i<100;i++) {
			System.out.println("main线程"+i);
		}
	}
}

结果可以看到交替出现

自定义线程方式（二）

自定义一个类去实现Runnable接口

（1）自定义一个类实现Runnable接口

（2）实现Runnable接口的run方法 把自定义线程的任务代码定义在run方法上

（3）创建Runnable实现类对象

（4）创建Thread对象 把Runnable实现类对象作为参数传入

（5）调用Thread的start方法开启线程

public class Demo implements Runnable {
	public static void main(String[] args) {
		Demo d=new Demo();
		Thread t=new Thread(d,"Mythread");
		t.start();
		for(int i=0;i<100;i++) {
			System.out.println("main线程"+i);
		}
	}

	@Override
	public void run() {
		// TODO Auto-generated method stub
		for(int i=0;i<100;i++) {
			System.out.println(Thread.currentThread().getName()+" "+i);
		}
	}
}

同样的我们看到结果的交替出现

这是我们来看一个问题 为什么要把Runnable实现类对象作为参数传递进去呢？

我们看两段Thread源码中的操作

//这个构造方法中 用target变量记录了Runnable实现类对象
public Thread(Runnable target, String name) {
        init(null, target, name, 0);
    }

/*这个是Thread类的run方法 可以看到在Thread的run方法中 又调用了
tatget的run方法 这个run方法就是我们自己重写的run方法*/
public void run() {
        if (target != null) {
            target.run();
        }
    }

这样我们在加深一下理解

public class Demo implements Runnable {
	public static void main(String[] args) {
		Demo d=new Demo();
		Thread t=new Thread(d,"Mythread");
		t.start();
		for(int i=0;i<100;i++) {
			System.out.println("main线程"+i);
		}
	}

	@Override
	public void run() {
		// TODO Auto-generated method stub
		for(int i=0;i<100;i++) {
			System.out.println(Thread.currentThread().getName()+" "+i);
		}
		System.out.println(Thread.currentThread());//当前线程对象 t
		System.out.println(this);//该函数的调用者对象 d
	}
}

this关键字指的是该函数的调用者对象 这个run方法目前是由target在调用 而恰恰target就是记录的Runnable实现类的对象 也就是d对象

线程生命周期

(害 本来想自己画图来 可是这个图太漂亮了 就直接拿过来了)

线程安全问题

我们来模拟一个线程安全问题

现在有这样一个需求 3个窗口要卖50张票 我们将3个窗口看做3个线程 来模拟实现这个问题

class TicketSales extends Thread{
	static int num=50;
	public  TicketSales(String name) {
		super(name);
	}
	@Override
	public void run() {
		while(true) {
			if(num>0) {
				System.out.println(Thread.currentThread().getName()+"卖出了"+num+"号票");
				num--;
			}else {
				System.out.println("售完了");
				break;
			}
		}
	}
}
public class Demo {
	public static void main(String[] args) {
		TicketSales thread1=new TicketSales("窗口1");
		TicketSales thread2=new TicketSales("窗口2");
		TicketSales thread3=new TicketSales("窗口3");
		thread1.start();
		thread2.start();
		thread3.start();
	}
}

这时候的结果 我们来看 出现了线程安全问题 50号票被卖了3次

我们来分析一下这个原因 可能的情况是当thread1刚刚执行到买票这句话是 还没来得及做num–时 这时候的cpu执行权被thread3 抢走了 同样的当thread3执行到买票这句话时 cpu的执行权又被thread2抢走了 这就造成了50号票被卖了3次的情况

同步代码块解决线程安全问题

class TicketSales extends Thread{
	static int num=50;
    //锁对象必须是多个线程共享的对象 否则没有意义 用static修饰
	static Object o=new Object();
	public  TicketSales(String name) {
		super(name);
	}
	@Override
	public void run() {
		while(true) {
			synchronized (o) {//o是多个线程共享的锁对象
				if(num>0) {
					System.out.println(Thread.currentThread().getName()+"卖出了"+num+"号票");
					num--;
				}else {
					System.out.println("售完了");
					break;
				}
			}
		}
	}
}
public class Demo {
	public static void main(String[] args) {
		TicketSales thread1=new TicketSales("窗口1");
		TicketSales thread2=new TicketSales("窗口2");
		TicketSales thread3=new TicketSales("窗口3");
		thread1.start();
		thread2.start();
		thread3.start();
	}
}

这时 利用同步代码块解决了线程安全问题

Lock锁与Synchronized的区别（附加内容）

这篇博客 写到这里 又去b战上搜了一下juc 于是又发现了新大陆 关于线程8锁 以后一定会加强自己的学习 这里先简单记录一下自己这个小的学习过程

(这里简单升级了一下代码 现学现卖 害）

我们来对比一下lock锁与synchronized的代码的不同写法以及区别

Synchronized方式

public class Demo {
	public static void main(String[] args) {	
		Ticket ticket=new Ticket();
        //lambda表达式 (参数)->{业务代码}
        //将资源类丢入到线程当中 这里大家可以去csdn搜一下lambda创建线程和传统方式创建线程
		new Thread(()->{for(int i=0;i<50;i++)ticket.sale();}).start();
		new Thread(()->{for(int i=0;i<50;i++)ticket.sale();}).start();
		new Thread(()->{for(int i=0;i<50;i++)ticket.sale();}).start();
	}
}
//资源类
class Ticket{
	private static int num=50;

	public synchronized void sale() {
		if(num>0) {
			System.out.println(Thread.currentThread().getName()+"卖出了"+num+"号票");
			num--;
		}
	}
}

Lock锁方式

public class Demo {
	public static void main(String[] args) {	
		Ticket ticket=new Ticket();
		new Thread(()->{for(int i=0;i<50;i++)ticket.sale();}).start();
		new Thread(()->{for(int i=0;i<50;i++)ticket.sale();}).start();
		new Thread(()->{for(int i=0;i<50;i++)ticket.sale();}).start();
	}
}
//资源类
class Ticket{
	private static int num=50;
	
	Lock lock=new ReentrantLock();
	public  void sale() {
		lock.lock();//加锁
		try {
			if(num>0) {
				System.out.println(Thread.currentThread().getName()+"卖出了"+num+"号票");
				num--;
			}
		} catch (Exception e) {
			
		}finally {
			lock.unlock();
		}
	}
}

Synchronized和Lock的区别

Synchronized 是内置的Java 关键字 Lock是Java类

Synchronized 无法判断锁的状态 Lock可以判断是否获取到了锁

Synchronized 会自动释放锁 Lock要手动释放锁

Synchronized 线程1(获得锁 阻塞) 线程2(等待 傻傻的等 ) Lock锁就不一定会等下去(会尝试获取锁)

Synchronized 可重入锁 不可中断 非公平锁 Lock 可重入锁 可以中断 默认非公平锁(可以自己设置)