Java基础（多线程）

一、多线程

1.多线程的概述

A:进程：进程指正在运行的程序。确切的来说，当一个程序进入内存运行，即变成

一个进程，进程是处于运行过程中的程序，并且具有一定独立功能。

B:线程：线程是进程中的一个执行单元，负责当前进程中程序的执行，一个进程中

至少有一个线程。一个进程中是可以有多个线程的，这个应用程序也可以称之为

多线程程序。

C:简而言之：一个程序运行后至少有一个进程，一个进程中可以包含多个线程

多线程即就是一个程序中有多个线程在同时执行。

Thread是程序中的执行线程。Java 虚拟机允许应用程序并发地运行多个执行线程。

构造方法：

Thread() ：分配新的 Thread 对象。

Thread(Runnable target) ：分配新的 Thread 对象。

Thread(Runnable target, String name)

成员方法：

void start()

          使该线程开始执行；Java 虚拟机调用该线程的 run 方法。

void run() ：

          如果该线程是使用独立的 Runnable 运行对象构造的，则调用该 Runnable 对

   象的run 方法；否则，该方法不执行任何操作并返回

static void sleep(long millis) ：

          在指定的毫秒数内让当前正在执行的线程休眠（暂停执行），此操作受到系统

    计时器和调度程序精度和准确性的影响。

2.多线程的实现第一种方式：

  a.定义一个类继承Thread。

  b.重写run方法。

  c.创建子类对象，就是创建线程对象。

  d.调用start方法，开启线程并让线程执行，同时还会告诉jvm去调用run方法

//线程子类

public class MyThread extends Thread {

@Override

public void run() {

for (int i = 0; i < 100; i++) {

System.out.println(getName() + ":" + i);

}

}

}

//测试类

public class ThreadDemo1 {

public static void main(String[] args) {

//创建线程实例

MyThread mt = new MyThread();

//修改线程名字

mt.setName("张三");

//启动线程

mt.start();

//创建线程实例

MyThread mt2 = new MyThread();

mt2.setName("老王");

//启动线程

mt2.start();

}

}

3.多线程的实现第二种方式

  Runnable接口用来指定每个线程要执行的任务。包含了一个 run 的无参数抽象

方法，需要由接口实现类重写该方法。

  创建线程的另一种方法是声明实现 Runnable 接口的类。该类然后实现 run 方

法。然后创建Runnable的子类对象，传入到某个线程的构造方法中，开

启线程。

   a、定义类实现Runnable接口。

   b、覆盖接口中的run方法。。

   c、创建Thread类的对象

   d、将Runnable接口的子类对象作为参数传递给Thread类的构造函数。

   e、调用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 < num; i++) {

//链式编程

System.out.println(Thread.currentThread().getName() + ":" +

i);

}

}

}

//测试类

public class ThreadDemo4 {

public static void main(String[] args) {

//创建Runable子类对象。

MyThread2 mt = new MyThread2(100);

new Thread(mt, "线程一").start();

new Thread(mt, "线程二").start();

}

}

4.多线程案例

/*

* 需求：

* 第一条线程计算1+2+3+4+5+...+100的和

* 第二条线程计算1+2+3+4+5+...+200的和

* 

*  线程一：5050

*  线程二：20100

*/

public class Test {

public static void main(String[] args) {

MyThread mt1 = new MyThread(100);

new Thread(mt1, "线程一").start();

MyThread mt2 = new MyThread(200);

new Thread(mt2, "线程二").start();

}

}

public class MyThread implements Runnable{

int num;

public MyThread(int num) {

this.num = num;

}

@Override

public void run() {

//求和

int sum = 0;

for(int i = 1; i <= num; i++) {

sum += i;

}

//输出结果

System.out.println(Thread.currentThread().getName() + "=" + sum);

}

}

5.模拟火车售票案例

synchronized:同步（锁），可以修饰代码块和方法，被修饰的代码块和方法一旦

被某个线程访问，则直接锁住，其他的线程将无法访问

      同步代码块：

            synchronized(锁对象){

            }

注意：锁对象需要被所有的线程所共享

//线程实现类

public class TicketThread implements Runnable {

int tickets = 100;//火车票数量

@Override

public void run() {

//出售火车票

while(true) {

synchronized (this) {

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();

}

}

6.同步方法

        格式:

       修饰符 synchronized 返回值 方法名(){

 

  }

同步方法:使用关键字synchronized修饰的方法，一旦被一个线程访问，则整个方

法全部锁住，其他线程则无法访问

     非静态的同步方法锁对象是this

     静态的同步方法锁对象是当前类的字节码对象

public class TicketThread implements Runnable {

static int tickets = 100;// 火车票数量

Object obj = new Object();

@Override

public void run() {

// 出售火车票

while (true) {

/*synchronized (obj) {

method();

}*/

//method();

method2();

}

}

private synchronized void method() {

if (tickets > 0) {

try {

Thread.sleep(100);

} catch (InterruptedException e) {

e.printStackTrace();

}

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

}

}

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();

}

}

7.线程的几种状态

新建-->就绪-->运行<-->阻塞-->死亡

8.死锁

/*

*  死锁

在同步代码块中又嵌套了一个同步代码块

多个线程之间使用的锁对象还刚好是相反的

例如：第一条线程先使用的是第一个锁对象，正在等待第二个锁对象。

第二条线程先使用的是第二个锁对象，正在等待第一个锁对象。

*/

public class Test01 {

public static void main(String[] args) {

final String s1 = "筷子左";

final String s2 = "筷子右";

new Thread() {

@Override

public void run() {

while(true) {

synchronized (s1) {

System.out.println("第一个人抢到了筷子左，等

  待筷子右");

synchronized (s2) {

System.out.println("第一个人抢到了筷子

                   右，开吃了.....");

}

}

}

}

}.start();

new Thread() {

@Override

public void run() {

while(true) {

synchronized (s2) {

System.out.println("第二个人抢到了筷子右，等

                    待筷子左");

synchronized (s1) {

System.out.println("第二个人抢到了筷子

                      左，开吃了.....");

}

}

}

}

}.start();

}

}