Java多线程(上篇)

每一个分支都叫做一个线程，main()叫做主分支，也叫主线程。

　　程只是一个静态的概念，机器上的一个.class文件，机器上的一个.exe文件，这个叫做一个进程。程序的执行过程都是这样的：首先把程序的代码放到内存的代码区里面，代码放到代码区后并没有马上开始执行，但这时候说明了一个进程准备开始，进程已经产生了，但还没有开始执行，这就是进程，所以进程其实是一个静态的概念，它本身就不能动。平常所说的进程的执行指的是进程里面主线程开始执行了，也就是main()方法开始执行了。进程是一个静态的概念，在我们机器里面实际上运行的都是线程。

　　Windows操作系统是支持多线程的，它可以同时执行很多个线程，也支持多进程，因此Windows操作系统是支持多线程多进程的操作系统。Linux和Uinux也是支持多线程和多进程的操作系统。DOS就不是支持多线程和多进程了，它只支持单进程，在同一个时间点只能有一个进程在执行，这就叫单线程。

　　CPU难道真的很神通广大，能够同时执行那么多程序吗？不是的，CPU的执行是这样的：CPU的速度很快，一秒钟可以算好几亿次，因此CPU把自己的时间分成一个个小时间片，我这个时间片执行你一会，下一个时间片执行他一会，再下一个时间片又执行其他人一会，虽然有几十个线程，但一样可以在很短的时间内把他们通通都执行一遍，但对我们人来说，CPU的执行速度太快了，因此看起来就像是在同时执行一样，但实际上在一个时间点上，CPU只有一个线程在运行。

学习线程首先要理清楚三个概念：

进程：进程是一个静态的概念

线程：一个进程里面有一个主线程叫main()方法，是一个程序里面的，一个进程里面不同的执行路径。

在同一个时间点上，一个CPU只能支持一个线程在执行。因为CPU运行的速度很快，因此我们看起来的感觉就像是多线程一样。
　　什么才是真正的多线程？如果你的机器是双CPU，或者是双核，这确确实实是多线程。

一、进程（process）

1. 程序是在某个操作系统中运行的，在系统中运行的程序就叫进程，进程是操作系统中的概念或叫法，程序=进程

2. 程序在运行期间，要占用CPU、内存等这些资源，这些资源的管理和调配都是由操作系统负责的

3. 一个程序至少对应一个进程，有些程序采用的是多进程架构设计

4. 进程间相互独立，不能互相访问或共享资源

二、线程(thread)

1.进程包含若干个线程 如果一个进程中只包含了一个线程，就叫单线程程序，如果一个进程中只包含了多个线程，就叫多线程程序

2.线程是程序(进程)中更小的一个执行单元

3.火车 - 某个车厢 QQ - 每个聊天窗口

4.一个进程可以拥有多个线程，但至少要有一个线程，即主执行线程(java的main方法)，我们之前写的都是单线程程序。

5.线程不能够单独执行，它必须运行在处于活动状态的进程中，它可与同属一个进程的其他线程共享进程所拥有的全部资源

三、多线程编程

1.JVM是从main方法开始执行的，执行的时候把main方法当成一个线程去执行

2.作用 效果 ：能让某些代码“同时”执行 让给两个for循环同时执行

3.大部分功能还是单线程即可，但是有时候也需要多线程：上传图片

A.一张一张传

B.多张图片同时上传

4.好处：提过代码执行的效率（多线程可以充分利用CPU和内存的资源）

5.生活案例：工厂刚成立时只有一条生产线，随着市场的开拓，为了提高生产效率，工厂不断增加生产线（生产线 = 线程）

四、多线程跟CPU

1.一心无二用，一个人能同时干多件事情吗？(边看片儿边写字)那计算机是怎么实现的呢？
真正的“同时”是不存在的，CPU在以极快的速度随机轮流执行程序，专业说法是程序在快速轮流抢占CPU资源。速度太快，人感觉不到

2.胶片电影

3.一个(程序)进程中如果只有一条生产线，这个程序称为单线程。
一个(程序)进程中如果有多条生产线，这个程序称为多线程。

4.多个线程同时执行时，CPU会随机性的、极快的、轮流的、执行每个线程。

五、Java的多线程

1.Java中有两类线程：User Thread(用户线程)、Daemon Thread(守护线程或后台服务线程) 。
守护线程的作用是为其他线程的运行提供服务，比如说GC线程。

2.在Java中实现多线程有两种方式：

方式一. 继承Thread类

方式二. 实现Runnable接口

六、方式一

1.一般的类都是很普通的类，类中的方法或其他代码都不能同时执行，都不是生产线类

2.在Java中，专门提供了一个现成的生产线类：Thread类

3.我们定义的普通的类可以继承Thread类，从而让这些普通类变成生产线类

4.步骤：

A.继承Thread类

B.重写run方法，把需要同时执行的代码放进去

C.在main方法中创建几条生产线

D.使用start()方法启动生产线

七、Thread类

public long getId()，获得该线程的标识符(线程 ID) ，它在创建该线程时生成。线程 ID 是唯一的，并终生不变。

public final void setName(String name)，给线程命名，不命名的话都有默认的，格式为：Thread-0、Thread-1…

public final String getName()，获得线程的名字

public void start()，使该线程开始执行，JVM会自动调用该线程的 run() 方法。

public static void sleep(long millis)，让线程休眠(暂停)多少毫秒

public static Thread currentThread()，获得当前正在执行的线程对象的引用。(方式二会用到)

八、多线程程序执行的流程

1.从main开始执行，这就是一个线程了，主线程

2.开始执行main方法中的代码，那么代码中的线程称之为其他线程

3.单线程程序，只要main方法执行完就表示程序结束；多线程程序，所有的线程都执行完，才表示程序结束

4.主线程的“主”不表示先执行或先执行完，表示这个线程是必须有的

九、方式二

1.自定义一个类实现Runnable接口，实现里面的run方法(需要同时执行的代码) —-不是生产线类

2.在main中创建几条生产线(Thread),需要把它要干的活儿传给它

3.启动生产线

当前线程：CPU当前正在干活的那个线程(currentThread())

代码举例：

/**
 * 继承Thread，生产线类
 */
public class T02_ThreadStudent extends Thread {

    public void run(){   //同时要执行的代码
        for (int i = 1; i <= 10; i++) {
            System.out.println(getName()+"在看第"+i+"页书");
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

/**
 * 实现Runnable接口，并不是生产线类
 */
public class T02_RunnableStudent implements Runnable{

    public void run() {
        for (int i = 1; i <= 10; i++) {
            System.out.println(Thread.currentThread().getName()+"在看第"+i+"页书");
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

    }
}

/**
 * Created by AFinalStone on 2017/6/30.
 */
public class T02_ExampleRunnableAndThread {

    public void testRunnable() {
        Thread t1 =new Thread(new T02_RunnableStudent());   //创建了一条生产线
        Thread t2 =new Thread(new T02_RunnableStudent());   //创建了一条生产线

        t1.start();   //启动
        t2.start();
    }

    public void testThread() {
        //用方式一实现两个学生同时看书(10页/100ms)
        //多线程编程
        //1.同时干什么事      看书    这部分代码应该放在run方法中
        //2.哪些名词应该充当生产线     生产线类
        //3.应该创建或启动几条生产线

        T02_ThreadStudent ts1=new T02_ThreadStudent();   //创建了一条生产线
        ts1.setName("张三");
        T02_ThreadStudent ts2=new T02_ThreadStudent();  //创建了一条生产线
        ts2.setName("李四");

        ts1.start();
        ts2.start();

        //思考：为什么不直接调用run()方法，而是调用start()方法来启动线程？
        //run()其实就是一个很普通的方法，而start()方法内部调用了run()，可以当成生产线去执行
    }

}

十、线程安全问题

1.概念：多个线程操作的是同一个共享资源，但是线程之间是彼此独立的，因此就会出现数据不同步更新的情况，这就是线程安全问题

2.条件：

a.多个线程

b.有共享资源

c.每个线程都操作或使用了共享资源（线程之间是互相独立的）

3.模拟实现：除夕那天北京到杭州的动车票只剩下10张，两个窗口同时在卖

a.同时要干的活：卖这10张票

b.自定义一个类型（不是生产线类）

c.在main中创建两个生产线(窗口)并启动

4.在代码中，共享资源怎么体现出来？共享资源一般通过属性来编写出来，在创建生产线时需要传进去同一个对象(run())

5.怎么解决线程安全问题？

大概的思路：就是把某些代码当成一个整体，就是给某些代码上锁 同步(锁)

6.在火车的车厢里上厕所

7.Java同步机制的实现方式：

a.同步代码块

b.同步方法(函数)

十一、同步代码快

1.语法格式：

synchronized（对象）{    //可以使用任意对象的锁，包括this
    操作共享数据的代码即需要同步的代码；
}

锁：监视器 遍地都是锁 任意一个对象内部都有一个监视器(锁)

十二、同步方法

public synchronized void sell(){  
    //锁是固定的this，即当前对象
    操作共享数据的代码即需要同步的代码；
}

把需要上锁的代码摘出来放到一个方法中，但是这个方法必须是同步方法，然后在run()中进行调用
同步方法的锁是固定不变的this,一个类中既可以有同步方法也可以有普通方法

• 代码举例：

public class T03_SaleWindow implements Runnable {

    private int ticket = 10;   //火车票的编号     共享资源

    public void run() {

        for (int i = 0; i < 10; i++) {
        {
            if (ticket >= 1) {
                System.out.println(Thread.currentThread().getName()
                        + "在卖编号为" + ticket + "的火车票");
                ticket--;
                try {
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            } else {
                System.out.println("没票了");
                break;
            }
        }
        }
    }
}

public class T03_SaleWindowSynchronized01 implements Runnable{

    private int  ticket = 10;   //火车票的编号     共享资源

    public void run() {

        for (int i = 0; i < 10; i++) {
            synchronized (this) {   //同步代码快
                if (ticket >= 1) {
                    System.out.println(Thread.currentThread().getName()
                            + "在卖编号为" + ticket + "的火车票");
                    ticket--;
                    try {
                        Thread.sleep(500);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                } else {
                    System.out.println("没票了");
                    break;
                }
            }
        }
    }
}

public class T03_SaleWindowSynchronized02 implements Runnable {

    private int ticket = 10; // 火车票的编号 共享资源

    public synchronized void sale() {

        if (ticket >= 1) {
            System.out.println(Thread.currentThread().getName() + "在卖编号为"
                    + ticket + "的火车票");
            ticket--;
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        } else {
            System.out.println("没票了");
        }

    }

    public void run() {
        for (int i = 0; i < 10; i++) {
            sale();
        }
    }
}

public class T03_ExampleSaleWindow {

    public void testSaleWindow(){
        T03_SaleWindow t03_saleWindow = new T03_SaleWindow();

        Thread t1 = new Thread(t03_saleWindow);   //窗口1
        Thread t2 = new Thread(t03_saleWindow);   //窗口2

        t1.start();
        t2.start();
    }

    public void testSaleWindowBySynchronized01(){
        T03_SaleWindowSynchronized01 sw = new T03_SaleWindowSynchronized01();

        Thread t1 = new Thread(sw);   //窗口1
        Thread t2 = new Thread(sw);   //窗口2

        t1.start();
        t2.start();
    }

    public void testSaleWindowBySynchronized02(){

        T03_SaleWindowSynchronized02 sw=new T03_SaleWindowSynchronized02();

        Thread t1=new Thread(sw);
        Thread t2=new Thread(sw);

        t1.start();
        t2.start();
    }
}

十三、细节

1.在解决线程安全问题时，多个线程使用的锁必须是同一把锁

同步的优劣：

2.优：能解决线程安全问题

3.劣：耗费大量资源，影响程序执行的速度(效率)

线程安全和性能不能兼得

4.静态方法能不能同步？类自身

项目地址：传送门