java线程基础

线程和进程

A:进程：进程指正在运行的程序。确切的来说，当一个程序进入内存运行，即变成一个进程，进程是处于运行过程中的程序，并且具有一定独立功能。
B:线程：线程是进程中的一个执行单元，负责当前进程中程序的执行，一个进程中至少有一个线程。一个进程中是可以有多个线程的，这个应用程序也可以称之为多线程程序。
C:简而言之：一个程序运行后至少有一个进程，一个进程中可以包含多个线程
什么是多线程呢？即就是一个程序中有多个线程在同时执行。

线程的两种实现方式

实现方式一：继承Thread类

创建线程的步骤：
1.定义一个类继承Thread。
2.重写run方法。
3.创建子类对象，就是创建线程对象。
4.调用start方法，开启线程并让线程执行，同时还会告诉jvm去调用run方法


代码案例：
public class MyThread extends Thread {
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println(getName() + ":" + i);
        }
    }
}




/*  Thread的方法
 *      String getName()      返回该线程的名称。 
 *      void   setName(String name) 改变线程名称，使之与参数 name 相同。
 * 
 * 
 * CPU执行程序的随机性
 */
public class ThreadDemo2 {
    public static void main(String[] args) {
        // 创建线程实例
        MyThread mt = new MyThread();
        // 修改线程名字
        mt.setName("thread1");

        //启动线程
        mt.start();

        //创建线程实例
        MyThread mt2 = new MyThread();
        mt2.setName("thread2");

        //启动线程
        mt2.start();
    }
}

实现方式二：继承Runnable接口

创建线程的步骤。
1、定义类实现Runnable接口。
2、覆盖接口中的run方法。。
3、创建Thread类的对象
4、将Runnable接口的子类对象作为参数传递给Thread类的构造函数。
5、调用Thread类的start方法开启线程。

代码案例

public class MyThread2 implements Runnable {
    int num;

    public MyThread2(int num) {
        this.num = num;
    }

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            //Thread t = Thread.currentThread();
            //System.out.println(t.getName() + ":" + i);

            //链式编程
            System.out.println(Thread.currentThread().getName() + ":" + i + num);
        }
    }

}

线程模拟售票，逐步解决安全问题

不加锁的情况下

需求:用三个线程模拟三个售票窗口,共同卖100张火车票,每个线程打印出卖第几张票

public class TicketThread implements Runnable {
    int tickets = 100;//火车票数量

    @Override
    public void run() {
        //出售火车票
        while(true) {
            //当火车票小于0张，则停止售票
            if(tickets > 0) {
                /*
                 * t1,t2,t3
                 * 假设只剩一张票
                 * t1过来了，他一看有票，他就进来了，但是他突然肚子不舒服，然后他就去上卫生间了
                 * t2也过来了，他一看也有票，他也进来了，但是他的肚子也不舒服，他也去上卫生间了
                 * 
                 * t1上完了卫生间回来了，开始售票
                 *  tickets = 0;
                 * t2也上完卫生间回来了，他也进行售票
                 *  tickets = -1;
                 * 
                 * 
                 */
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) { 
                    e.printStackTrace();
                }

                System.out.println(Thread.currentThread().getName() + ":" +tickets--);
            }
        }
    }

}

使用同步代码块

同步代码块格式:
  synchronized(锁对象){
      //需要同步的代码
}

代码案例：

/**
*  synchronized:同步（锁），可以修饰代码块和方法，
*     被修饰的代码块和方法一旦被某个线程访问，则直接锁住，
*     其他的线程将无法访问   
*  注意：锁对象需要被所有的线程所共享
* 
*  同步：安全性高，效率低
*  非同步：效率高，但是安全性低
*/
public class TicketThread implements Runnable {
    int tickets = 100;//火车票数量

    // 用作同步代码块的锁
    Object obj = new Object();

    @Override
    public void run() {
        //出售火车票
        while(true) {
            synchronized (obj) {

                if(tickets > 0) {

                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }

                    System.out.println(Thread.currentThread().getName() + ":" +tickets--);
                }
            }

        }
    }

}



public class TicktetTest {
    public static void main(String[] args) {
        //创建线程对象
        TicketThread tt = new TicketThread();

        Thread t = new Thread(tt);
        t.setName("窗口1");
        Thread t2 = new Thread(tt);
        t2.setName("窗口2");
        Thread t3 = new Thread(tt);
        t3.setName("窗口3");

        //启动线程对象
        t.start();
        t2.start();
        t3.start();
    }
}

使用同步方法

 同步方法格式:
  修饰符 synchronized 返回值 方法名(){

  }

代码案例：

/*
 * 同步方法:使用关键字synchronized修饰的方法，
 * 一旦被一个线程访问，则整个方法全部锁住，其他线程则无法访问
 * 
 * synchronized
 * 注意：
 *      非静态同步方法的锁对象是this
 *      静态的同步方法的锁对象是当前类的字节码对象
 */
    public class TicketThread implements Runnable {
    static int tickets = 100;// 火车票数量
    Object obj = new Object();

    @Override
    public void run() {
        // 出售火车票
        while (true) {
            method2();
        }
    }

    private static synchronized void method2() {

        if (tickets > 0) {

            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            System.out.println(Thread.currentThread().getName() + ":" + tickets--);
        }
    }



}


public class TicktetTest {
    public static void main(String[] args) {
        //创建线程对象
        TicketThread tt = new TicketThread();

        Thread t = new Thread(tt);
        t.setName("窗口1");
        Thread t2 = new Thread(tt);
        t2.setName("窗口2");
        Thread t3 = new Thread(tt);
        t3.setName("窗口3");

        //启动线程对象
        t.start();
        t2.start();
        t3.start();
    }
}