JAVASE基础 Item -- 多线程，并发_多线程用item-&gt；{}

最新推荐文章于 2024-07-10 21:39:46 发布

2401_85124892

最新推荐文章于 2024-07-10 21:39:46 发布

阅读量387

点赞数 4

分类专栏：作者\/ 文章标签： php 开发语言

本文链接：https://blog.csdn.net/2401_85124892/article/details/139240846

版权

作者\/ 专栏收录该内容

30 篇文章 0 订阅

订阅专栏

    ThreadSleep ts3 = new ThreadSleep();

    ts1.setName("林青霞");
    ts2.setName("林志玲");
    ts3.setName("林志颖");

    ts1.start();
    ts2.start();
    ts3.start();
}

}


* **2、线程加入**


	+ public final void join()–等待该线程终止。创建线程ThreadJoin

package cn.itcast_04;

public class ThreadJoin extends Thread {
@Override
public void run() {
for (int x = 0; x < 100; x++) {
System.out.println(getName() + “:” + x);
}
}
}

package cn.itcast_04;

/*
* public final void join():等待该线程终止。
*/
public class ThreadJoinDemo {
public static void main(String[] args) {
ThreadJoin tj1 = new ThreadJoin();
ThreadJoin tj2 = new ThreadJoin();
ThreadJoin tj3 = new ThreadJoin();

    tj1.setName("李渊");
    tj2.setName("李世民");
    tj3.setName("李元霸");

    tj1.start();
    try {
        tj1.join();//先有李渊，才有后面的两个线程。
    } catch (InterruptedException e) {
        e.printStackTrace();
    }

    tj2.start();
    tj3.start();
}

}


* **3、线程礼让**   

	+ public static void yield()


创建线程ThreadYield

package cn.itcast_04;

public class ThreadYield extends Thread {
@Override
public void run() {
for (int x = 0; x < 100; x++) {
System.out.println(getName() + “:” + x);
Thread.yield();
}
}
}

package cn.itcast_04;

/*
* public static void yield():暂停当前正在执行的线程对象，并执行其他线程。
* 让多个线程的执行更和谐，但是不能靠它保证一人一次。
*/
public class ThreadYieldDemo {
public static void main(String[] args) {
ThreadYield ty1 = new ThreadYield();
ThreadYield ty2 = new ThreadYield();

    ty1.setName("林青霞");
    ty2.setName("刘意");

    ty1.start();
    ty2.start();
}

}


* **4、后台线程（线程守护）**   

	+ public final void setDaemon(boolean on)


创建线程ThreadDaemon

package cn.itcast_04;

public class ThreadDaemon extends Thread {
@Override
public void run() {
for (int x = 0; x < 100; x++) {
System.out.println(getName() + “:” + x);
}
}
}

package cn.itcast_04;

/*
* public final void setDaemon(boolean on):将该线程标记为守护线程或用户线程。
* 当正在运行的线程都是守护线程时，Java 虚拟机退出。该方法必须在启动线程前调用。
*
* 游戏：坦克大战。
*/
public class ThreadDaemonDemo {
public static void main(String[] args) {
ThreadDaemon td1 = new ThreadDaemon();
ThreadDaemon td2 = new ThreadDaemon();

    td1.setName("关羽");
    td2.setName("张飞");

    // 设置守护线程
    td1.setDaemon(true);
    td2.setDaemon(true);

    td1.start();
    td2.start();

    Thread.currentThread().setName("刘备");// 刘备死了，关于和张飞也得挂。
    for (int x = 0; x < 5; x++) {
        System.out.println(Thread.currentThread().getName() + ":" + x);
    }
}

}


* **5、中断线程**   

	+ public final void stop()–已过时
	+ public void interrupt()


创建线程ThreadStop

package cn.itcast_04;

import java.util.Date;

public class ThreadStop extends Thread {
@Override
public void run() {
System.out.println(“开始执行：” + new Date());

    // 我要休息10秒钟，亲，不要打扰我哦
    try {
        Thread.sleep(10000);
    } catch (InterruptedException e) {
        // e.printStackTrace();
        System.out.println("线程被终止了");
    }

    System.out.println("结束执行：" + new Date());
}

}

package cn.itcast_04;

/*
* public final void stop():让线程停止，过时了，但是还可以使用。
* public void interrupt():中断线程。把线程的状态终止，并抛出一个InterruptedException。
*/
public class ThreadStopDemo {
public static void main(String[] args) {
ThreadStop ts = new ThreadStop();
ts.start();

    // 你超过三秒不醒过来，我就干死你
    try {
        Thread.sleep(3000);
        // ts.stop();
        ts.interrupt();
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
}

}


### 四、线程生命周期


![这里写图片描述](https://img-blog.csdn.net/20160227212942208)


### 五、多线程程序练习


**需求：**   
 某电影院目前正在上映贺岁大片，共有100张票，而它有3个售票窗口售票，请设计一个程序模拟该电影院售票。   
 两种方式实现


* 继承Thread类
* 实现Runnable接口


1、创建买票进程

package cn.itcast_06;

public class SellTicket extends Thread {

// 定义100张票
// private int tickets = 100;
// 为了让多个线程对象共享这100张票，我们其实应该用静态修饰
private static int tickets = 100;

@Override
public void run() {
    // 定义100张票
    // 每个线程进来都会走这里，这样的话，每个线程对象相当于买的是自己的那100张票，这不合理，所以应该定义到外面
    // int tickets = 100;

    // 是为了模拟一直有票
    while (true) {
        if (tickets > 0) {
            System.out.println(getName() + "正在出售第" + (tickets--) + "张票");
        }
    }
}

}

package cn.itcast_06;

/*
* 某电影院目前正在上映贺岁大片(红高粱,少林寺传奇藏经阁)，共有100张票，而它有3个售票窗口售票，请设计一个程序模拟该电影院售票。
* 继承Thread类来实现。
*/
public class SellTicketDemo {
public static void main(String[] args) {
// 创建三个线程对象
SellTicket st1 = new SellTicket();
SellTicket st2 = new SellTicket();
SellTicket st3 = new SellTicket();

    // 给线程对象起名字
    st1.setName("窗口1");
    st2.setName("窗口2");
    st3.setName("窗口3");

    // 启动线程
    st1.start();
    st2.start();
    st3.start();
}

}


![这里写图片描述](https://img-blog.csdn.net/20160227213656471)


我们前面讲解过电影院售票程序，从表面上看不出什么问题，但是在真实生活中，售票时网络是不能实时传输的，总是存在延迟的情况，所以，在出售一张票以后，需要一点时间的延迟。


改实现接口方式的卖票程序，每次卖票延迟100毫秒

package cn.itcast_08;

public class SellTicket implements Runnable {
// 定义100张票
private int tickets = 100;

// @Override
// public void run() {
// while (true) {
// // t1,t2,t3三个线程
// // 这一次的tickets = 100;
// if (tickets > 0) {
// // 为了模拟更真实的场景，我们稍作休息
// try {
// Thread.sleep(100); // t1就稍作休息,t2就稍作休息
// } catch (InterruptedException e) {
// e.printStackTrace();
// }
//
// System.out.println(Thread.currentThread().getName() + "正在出售第"
// + (tickets--) + "张票");
// // 理想状态：
// // 窗口1正在出售第100张票
// // 窗口2正在出售第99张票
// // 但是呢?
// // CPU的每一次执行必须是一个原子性(最简单基本的)的操作。
// // 先记录以前的值
// // 接着把ticket--
// // 然后输出以前的值(t2来了)
// // ticket的值就变成了99
// // 窗口1正在出售第100张票
// // 窗口2正在出售第100张票
//
// }
// }
// }

@Override
public void run() {
    while (true) {
        // t1,t2,t3三个线程
        // 这一次的tickets = 1;
        if (tickets > 0) {
            // 为了模拟更真实的场景，我们稍作休息
            try {
                Thread.sleep(100); // t1进来了并休息，t2进来了并休息，t3进来了并休息，
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            System.out.println(Thread.currentThread().getName() + "正在出售第"
                    + (tickets--) + "张票");
            // 窗口1正在出售第1张票,tickets=0
            // 窗口2正在出售第0张票,tickets=-1
            // 窗口3正在出售第-1张票,tickets=-2
        }
    }
}

}

package cn.itcast_08;

/*
* 实现Runnable接口的方式实现
*
* 通过加入延迟后，就产生了连个问题：
* A:相同的票卖了多次
* CPU的一次操作必须是原子性的
* B:出现了负数票
* 随机性和延迟导致的
*/
public class SellTicketDemo {
public static void main(String[] args) {
// 创建资源对象
SellTicket st = new SellTicket();

    // 创建三个线程对象
    Thread t1 = new Thread(st, "窗口1");
    Thread t2 = new Thread(st, "窗口2");
    Thread t3 = new Thread(st, "窗口3");

    // 启动线程
    t1.start();
    t2.start();
    t3.start();
}

}


![这里写图片描述](https://img-blog.csdn.net/20160227214322364)   
 **问题**


* 相同的票出现多次   
 **CPU的一次操作必须是原子性的**
* 还出现了负数的票   
 **随机性和延迟导致的**


注意   
 线程安全问题在理想状态下，不容易出现，但一旦出现对软件的影响是非常大的。


### 六、线程同步


##### **6.1、解决线程安全问题的基本思想**


首先想为什么出现问题?(也是我们判断是否有问题的标准)   
 **1、是否是多线程环境**   
 **2、是否有共享数据**   
 **3、是否有多条语句操作共享数据**


如何解决多线程安全问题呢?   
 基本思想：**让程序没有安全问题的环境。**   
 怎么实现呢?   
 把多个语句操作共享数据的代码给锁起来，让任意时刻只能有一个线程执行即可。


##### **6.2 解决线程安全问题实现1——同步代码块**


格式：   
 **synchronized(对象){需要同步的代码;}**


同步可以解决安全问题的根本原因就在那个对象上。该对象如同锁的功能（只能有一把锁）。   
 同步代码块的对象可以是哪些呢?

package cn.itcast_09;

public class SellTicket implements Runnable {
// 定义100张票
private int tickets = 100;
// 创建锁对象
private Object obj = new Object();

// @Override
// public void run() {
// while (true) {
// synchronized(new Object()){ //这个每个进程进来都new一个，就不是同一个了，每个人都有同一把锁。
// if (tickets > 0) {
// try {
// Thread.sleep(100);
// } catch (InterruptedException e) {
// e.printStackTrace();
// }
// System.out.println(Thread.currentThread().getName() + "正在出售第"
// + (tickets--) + "张票");
// }
// }
// }
// }

@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--) + "张票");
            }
        }
    }
}

}

package cn.itcast_09;

/*
* 如何解决线程安全问题呢?
*
* 要想解决问题，就要知道哪些原因会导致出问题:(而且这些原因也是以后我们判断一个程序是否会有线程安全问题的标准)
* A:是否是多线程环境
* B:是否有共享数据
* C:是否有多条语句操作共享数据
*
* 我们来回想一下我们的程序有没有上面的问题呢?
* A:是否是多线程环境是
* B:是否有共享数据是
* C:是否有多条语句操作共享数据是
*
* 由此可见我们的程序出现问题是正常的，因为它满足出问题的条件。
* 接下来才是我们要想想如何解决问题呢?
* A和B的问题我们改变不了，我们只能想办法去把C改变一下。
* 思想：
* 把多条语句操作共享数据的代码给包成一个整体，让某个线程在执行的时候，别人不能来执行。
* 问题是我们不知道怎么包啊?其实我也不知道，但是Java给我们提供了：同步机制。
*
* 同步代码块：
* synchronized(对象){
* 需要同步的代码;
* }
*
* A:对象是什么呢?
* 我们可以随便创建一个对象试试。
* B:需要同步的代码是哪些呢?
* 把多条语句操作共享数据的代码的部分给包起来
*
* 注意：
* 同步可以解决安全问题的根本原因就在那个对象上。该对象如同锁的功能。
* 多个线程必须是同一把锁。
*/
public class SellTicketDemo {
public static void main(String[] args) {
// 创建资源对象
SellTicket st = new SellTicket();

    // 创建三个线程对象
    Thread t1 = new Thread(st, "窗口1");
    Thread t2 = new Thread(st, "窗口2");
    Thread t3 = new Thread(st, "窗口3");

    // 启动线程
    t1.start();
    t2.start();
    t3.start();
}

}


##### **6.3 解决线程安全问题实现2——同步方法**


就是把同步关键字加到方法上   
 **同步方法的锁对象是什么呢?**


* 如果是静态方法，同步方法的锁对象又是什么呢?
* 那么，我们到底使用谁?   
 **如果锁对象是this，就可以考虑使用同步方法。**   
 **否则能使用同步代码块的尽量使用同步代码块。**

package cn.itcast_11;

public class SellTicket implements Runnable {

// 定义100张票
private static int tickets = 100;

// 定义同一把锁
private Object obj = new Object();
private Demo d = new Demo();

private int x = 0;

//同步代码块用obj做锁

// @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–) + "张票 ");
// }
// }
// }
// }

//同步代码块用任意对象做锁

// @Override
// public void run() {
// while (true) {
// synchronized (d) {
// if (tickets > 0) {
// try {
// Thread.sleep(100);
// } catch (InterruptedException e) {
// e.printStackTrace();
// }
// System.out.println(Thread.currentThread().getName()
// + “正在出售第” + (tickets–) + "张票 ");
// }
// }
// }
// }

@Override
public void run() {
    while (true) {
        if(x%2==0){
            synchronized (SellTicket.class) {//非静态的，使用this即可
                if (tickets > 0) {
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName()
                            + "正在出售第" + (tickets--) + "张票 ");
                }
            }
        }else {

// synchronized (d) {
// if (tickets > 0) {
// try {
// Thread.sleep(100);
// } catch (InterruptedException e) {
// e.printStackTrace();
// }
// System.out.println(Thread.currentThread().getName()
// + “正在出售第” + (tickets–) + "张票 ");
// }
// }

            sellTicket();

        }
        x++;
    }
}

// private void sellTicket() {
// synchronized (d) {
// if (tickets > 0) {
// try {
// Thread.sleep(100);
// } catch (InterruptedException e) {
// e.printStackTrace();
// }
// System.out.println(Thread.currentThread().getName()
// + “正在出售第” + (tickets–) + "张票 ");
// }
// }
// }

//如果一个方法一进去就看到了代码被同步了，那么我就再想能不能把这个同步加在方法上呢?

// private synchronized void sellTicket() {
// if (tickets > 0) {
// try {
// Thread.sleep(100);
// } catch (InterruptedException e) {
// e.printStackTrace();
// }
// System.out.println(Thread.currentThread().getName()
// + “正在出售第” + (tickets–) + "张票 ");
// }
// }

private static synchronized void sellTicket() {
    if (tickets > 0) {
    try {
            Thread.sleep(100);
    } catch (InterruptedException e) {
            e.printStackTrace();
    }
    System.out.println(Thread.currentThread().getName()
                + "正在出售第" + (tickets--) + "张票 ");
    }

}
}

class Demo {
}

package cn.itcast_11;

/*
* A:同步代码块的锁对象是谁呢?
* 任意对象。
*
* B:同步方法的格式及锁对象问题?
* 把同步关键字加在方法上。
*
* 同步方法是谁呢?
* this
*
* C:静态方法及锁对象问题?
* 静态方法的锁对象是谁呢?
* 类的字节码文件对象。(反射会讲)
*/
public class SellTicketDemo {
public static void main(String[] args) {
// 创建资源对象
SellTicket st = new SellTicket();

    // 创建三个线程对象
    Thread t1 = new Thread(st, "窗口1");
    Thread t2 = new Thread(st, "窗口2");
    Thread t3 = new Thread(st, "窗口3");

    // 启动线程
    t1.start();
    t2.start();
    t3.start();
}

}


##### **6.4 同步的特点**


* **同步的前提**   

	+ 多个线程
	+ 多个线程使用的是同一个锁对象
* **同步的好处**   

	+ 同步的出现解决了多线程的安全问题。
* **同步的弊端**   

	+ 当线程相当多时，因为每个线程都会去判断同步上的锁，这是很耗费资源的，无形中会降低程序的运行效率。


##### **6.5 线程安全的类**(看看源码)


* StringBuffer/StringBuilder
* Vector
* Hashtable   
 以及Collections中的让集合同步功能。

package cn.itcast_12;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Hashtable;
import java.util.List;
import java.util.Vector;

public class ThreadDemo {
public static void main(String[] args) {
// 线程安全的类
StringBuffer sb = new StringBuffer();
Vector v = new Vector();
Hashtable<String, String> h = new Hashtable<String, String>();

    // Vector是线程安全的时候才去考虑使用的，但是我还说过即使要安全，我也不用你
    // 那么到底用谁呢?
    // public static <T> List<T> synchronizedList(List<T> list)
    List<String> list1 = new ArrayList<String>();// 线程不安全
    List<String> list2 = Collections
            .synchronizedList(new ArrayList<String>()); // 线程安全
}

2401_85124892

关注

4
点赞
踩
5

收藏

觉得还不错? 一键收藏
0
评论
JAVASE基础 Item -- 多线程，并发_多线程用item-&gt；{}

public static void yield():暂停当前正在执行的线程对象，并执行其他线程。* 当正在运行的线程都是守护线程时，Java 虚拟机退出。// + “正在出售第” + (tickets–) + "张票 ");// + “正在出售第” + (tickets–) + "张票 ");// + “正在出售第” + (tickets–) + "张票 ");// + “正在出售第” + (tickets–) + "张票 ");// + “正在出售第” + (tickets–) + "张票 ");
复制链接

扫一扫