初识多线程
一.进程的认识：
1.进程的理解：
进程可以理解成正在执行的任务，就是正在运行的程序，进程又分为两种，一种是前台进程，就是我们很直观看见的，另一种是后台进程，就是操作系统启动就有的(系统级的进程)，每个进程运行之后都会占用一定的cpu和内存资源；
比如说：我们打开window任务管理器就可以看到有很多的进程，里面有用户开启的，也有操作系统启动的进程
2.进程的调度：
也就是那么多的进程，cpu是怎样运行的呢？
采用时间片轮转法
二.线程认识
1.线程的理解
线程是在进程的内部运行的执行体
(1).一个进程可以创建多个线程
(2).进程和线程共同来争夺cpu，而且概率是均等的
(3).线程依赖进程，不能独立存在
(4).在java中，一个进程至少有一个线程，main方法被称为主线程；
我们可以在java的main方法中输出一个1/0；
(5).进程或者线程都有优先级，优先级高的可以得到更多的时间片和cpu的执行权
(6).抢占式调度：优先级高的进程可以抢占优先级低的cpu执行权
2.为什么要搞多线程？
原因：
(1).让多个程序同时执行
(2).提高程序的执行效率
三.线程的创建
1.方式一：继承Thread类
小demo：
1 //定义一个类，继承Thread类
2 public class MyThread extends Thread {
3
4 //重写Thread类的run方法
5 public void run(){
6 System.out.print("我是一个子线程");
7 }
8 }
1 public class Demo {
2 public static void main(String[] args) {
3 //创建子类对象，然后调用start();方法
4 MyThread mt=new MyThread();
5 mt.start();
6 }
7 }
2.方式二：实现Runnable接口
小demo：
//实现类的定义
public class MyRunnableImpl implements Runnable {
//定义一个Runnable实现类，然后重写run方法
@Override
public void run() {
//这里写功能代码
}
}
1 public class Demo {
2 //使用代码
3 public static void main(String[] args) {
4 //new 一个Runnable实现类对象
5 MyRunnableImpl my=new MyRunnableImpl();
6 //然后将该实现类对象，传入Thread类的构造方法中，并创建Thread类对象
7 //调用Thread对象start()方法开启线程
8 new Thread(my).start();
9 }
10 }
四.线程的安全
1.线程安全问题产生的原因：
当多个线程去访问共享资源时候，就会发生线程安全问题
先看一个案例：多窗口卖电影票的案例
1 class Ticket implements Runnable {
2 //电影票的数量
3 private static int ticket=100;
4 @Override
5 public void run() {
6 while(true){
7 if(ticket>0){
8 //模拟网络延时的场景
9 try {
10 Thread.sleep(50);
11 } catch (InterruptedException e) {
12 // TODO Auto-generated catch block
13 e.printStackTrace();
14 }
15 //对票数进行出售(减减操作)
16 System.out.println("正在售出第"+ticket--+"张票");
17 }
18 }
19 }
20 }
21 public class Demo {
22 public static void main(String[] args) {
23 //new 一个实现类对象
24 Ticket t=new Ticket();
25 //创建3个线程对电影票进行售卖
26 new Thread(t).start();
27 new Thread(t).start();
28 new Thread(t).start();
29
30 }
31 }
这时候就出现了问题：
出现这个问题的解释：
当拥还剩一张电影票的时候，拥有cpu执行权的线程运行到while(true)的时候，顺利通过，然后在运行sleep();这时候这个线程进入堵塞状态，电影票还是1，cpu的执行权被另一个线程拿到，也正好运行到while(true)，顺利通过，然后在运行sleep();cpu执行权被第三个线程抢去，同样的运行，到最后醒过来的线程会继续执行下面的代码。就产生了负数票的现象
2.线程安全问题的解决方案：
(1).同步代码块
1
2 //定义一个对象，当做锁对象
3 static Object obj = new Object();
4 /*
5 同步代码块：
6 参数：锁对象
7 1:java任何对象都可以作为锁对象
8 2:所有的线程都必须共享这个锁对象(该对象只有一份)
9 synchronized(mutex){
10 //存放需要加锁的代码
11 }
12 */
13
14 //实现卖票的代码
15 @Override
16 public void run() {
17
18 while(true){
19 synchronized (obj) {//加锁
20 if(tickets > 0 ){
21 //模拟一个网络的延时
22 try{Thread.sleep(50);}catch(Exception e){}
23 System.out.println("正在出售第"+ tickets-- + "张票");
24 }
25 }//解锁
26 }
27 }
(2).同步方法
1 /*
2 * 同步方法：对整个方法加锁
3 *
4 * 1:同步方法的锁对象是this, 这里的this必须是同一个
5 * 2:静态方法的锁对象是：类名.class
6 */
7 /*
8 * 同步代码块和同步方法的区别:
9 * 1:同步代码块可以对任何一段代码进行加锁
10 * 2:同步方法是对整个方法都进行加锁
11 *
12 *
13 * 3:同步代码块的对象可以自己指定
14 * 4:同步方法的锁对象必须是this
15 */
16 public synchronized void method(){
17 if (tickets > 0) {
18 // 模拟一个网络的延时
19 try {
20 Thread.sleep(50);
21 } catch (Exception e) {
22 }
23 System.out.println("正在出售第" + tickets-- + "张票");
24 }
25 }
26
27 // 实现卖票的代码
28 @Override
29 public void run() {
30
31 while (true) {
32 method();
33 }
34 }
(3).同步锁
1 /*
2 * 同步锁：
3 * Lock接口:
4 * ReentrantLock实现类:
5 * lock()； 加锁
6 * unlock()；解锁
7 */
8
9 //1:创建锁对象
10 ReentrantLock rt = new ReentrantLock();
11
12
13 // 实现卖票的代码
14 @Override
15 public void run() {
16
17 while (true) {
18 //2:在适当的地方加锁
19 rt.lock();
20
21 if (tickets > 0) {
22 // 模拟一个网络的延时
23 try {
24 Thread.sleep(50);
25 } catch (Exception e) {
26 }
27 System.out.println("正在出售第" + tickets-- + "张票");
28 }
29 //3:在适当的地方解锁
30 rt.unlock();
31 }
32 }
五.线程的状态
