- 前言,前段时间一直在研究JavaWeb方向,最近闲下来,回过头来看看线程,又有不一样的见解。
package sh.thread;
public class ThreadDemo1 extends Thread{
//1.自定义线程要执行的目标代码
@Override
public void run() {
for(int i=0;i<10;i++){
System.out.println("线程1:"+i);
}
}
public static void main(String[] args){
//2.创建自定义线程类的对象
ThreadDemo1 T1 = new ThreadDemo1();
//3.调用start方法启动线程
T1.start();
for(int i=0;i<5;i++){//main主线程
System.out.println("线程2:"+i);
}
}
}
/*
* 1.线程基础知识:
* 进程:正在执行的程序称作为一个进程。 进程负责了内存空间的划分。
* 线程:线程在一个进程中 负责了代码的执行,就是进程中一个执行路径。
* 多线程:在一个进程中有多个线程(多个不同路径),同时在执行不同的任务。
*
* 2.多线程的好处:
* 1.解决了一个进程能同时执行多个任务的问题。(高并发点击网页必须的!厉害吧,骚年!)
* 2.提高了资源的利用率。
*
* 3.多线程的弊端:
* 1.增加cpu的的负担。
* 2.降低了一个进程中线程的执行概率。
* 3.引发了线程安全问题。
* 3.出现了死锁现象。
*
* 4.创建线程的方式:
* 方法一:
* 1.自定义一个类继承Thread类。
* 2.重写Thread类的run方法,把自定义线程的任务代码写在run方法中
* (重写的目的:每个线程都有自己的任务代码,jvm创建的主线程的任务代码就是
* main方法中的所有代码,而自定义线程的任务代码就写在run方法中)
* 3.创建Thread的子类对象,并且调用start方法开启线程。
* 注意:一个线程一旦开启,那么线程就会执行run方法中的代码,run方法千万不能直接调用,
* 直接调用 就相当调用了一个普通的方法而并没有开启新的线程。
* */
- 用上面的一个基础线程,引出线程生命周期图,嗯,非常清晰了。
- 线程的一些常用方法及注解
package sh.thread;
public class ThreadDemo2 extends Thread{
/*
5. 线程常用的方法:
Thread(String name) 初始化线程的名字
setName(String name) 设置线程对象名
getName() 返回线程的名字
sleep() 静态:在哪个线程内,就是那个线程 线程睡眠指定的毫秒数。 静态的方法, 那个线程执行了sleep方法代码那么就是那个线程睡眠。
currentThread() 静态:同上 返回当前的线程对象,该方法是一个静态的方法, 注意: 那个线程执行了currentThread()代码就返回那个线程 的对象。
getPriority() 返回当前线程对象的优先级 默认线程的优先级是5
setPriority(int newPriority) 设置线程的优先级 虽然设置了线程的优先级,但是具体的实现取决于底层的操作系统的实现(最大的优先级是10 ,最小的1 , 默认是5)。
*/
public ThreadDemo2(String name){
super(name);//调用了Thread类的一个 参数的构造方法。
}
@Override
public void run() {
/*System.out.println("this:"+ this); //this对象与当前线程对象是同一个
System.out.println("当前线程对象:" + Thread.currentThread()); */
for (int i = 0; i < 100 ; i++) {//自定义线程目标代码
System.out.println(Thread.currentThread().getName()+":"+i);
/*try {
Thread.sleep(100); //为什么在这里不能抛出异常,只能捕获?? Thread类的run方法没有抛出异常类型,所以子类不能抛出异常类型(子类不能超过父类)
} catch (InterruptedException e) {
e.printStackTrace();
} */
}
}
public static void main(String[] args) throws InterruptedException {
//创建了一个线程对象
ThreadDemo2 d = new ThreadDemo2("狗剩哥");
d.setPriority(10); //设置线程 的优先级。 优先级的数字越大,优先级越高 , 优先级的范围是1~10
d.start();
for (int i = 0; i < 100 ; i++) {//主线程目标代码
System.out.println(Thread.currentThread().getName()+":"+i);
}
/*
System.out.println("自定义线程的优先级:"+d.getPriority()); //线程的优先级默认是5
System.out.println("主线程的优先级:"+Thread.currentThread().getPriority());
d.start();
d.setName("铁蛋"); //setName设置线程的名字
d.start(); //开启线程
Thread mainThread = Thread.currentThread();
System.out.println("主线程的名字:"+ mainThread.getName());
*/
}
}
4 .好吧,经典的多线程卖票问题,当时懵逼的有木有!,现在看来,不过尔尔…
package sh.thread;
/*
1. 需求: 模拟3个窗口同时在售50张 票 。
问题1 :为什么50张票被卖出了150次?
出现 的原因: 因为num是非静态的,非静态的成员变量数据是在每个对象中都会维护一份数据的,三个线程对象就会有三份。
2. 解决方案:把num票数共享出来给三个线程对象使用。使用static修饰。
问题2: 出现了线程安全问题 ?
3. 线程 安全问题的解决方案:sun提供了线程同步机制让我们解决这类问题的。
java线程同步机制的方式:
方式一:同步代码块
同步代码块的格式:
synchronized(锁对象){
需要被同步的代码...
}
4. 同步代码块要注意事项:
1. 任意的一个对象都可以做为锁对象。
2. 在同步代码块中调用了sleep方法并不是释放锁对象的。
3. 只有真正存在线程安全问题的时候才使用同步代码块,否则会降低效率的。
4. 多线程操作的锁 对象必须 是唯一共享 的。否则无效。
5. 出现线程安全问题的根本原因:
1. 存在两个或者两个以上 的线程对象,而且线程之间共享着一个资源。
2. 有多个语句操作了共享资源。
*/
class SaleTicket extends Thread{
static int num = 50;//票数 非静态的成员变量,非静态的成员变量数据是在每个对象中都会维护一份数据的。
static Object o = new Object();//定义一个唯一共享的锁对象
public SaleTicket(String name) {
super(name);
}
@Override
public void run() {
while(true){
//同步代码块
synchronized (o) {
if(num>0){
System.out.println(Thread.currentThread().getName()+"售出了第"+num+"号票");
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
num--;
}else{
System.out.println("卖完了..");
break;
}
}
}
}
}
public class ThreadDemo3 {
public static void main(String[] args) {
//创建三个线程对象,模拟三个窗口
SaleTicket thread1 = new SaleTicket("窗口1");
SaleTicket thread2 = new SaleTicket("窗口2");
SaleTicket thread3 = new SaleTicket("窗口3");
//开启线程售票
thread1.start();
thread2.start();
thread3.start();
}
}
5.线程通讯: 一个线程完成了自己的任务时,要通知另外一个线程去完成另外一个任务.
例子:生产者-消费者
package sh.thread;
/*
线程通讯: 一个线程完成了自己的任务时,要通知另外一个线程去完成另外一个任务.
生产者与消费者
wait(): 等待 如果线程执行了wait方法,那么该线程会进入等待的状态,等待状态下的线程必须要被其他线程调用notify方法才能唤醒。
notify(): 唤醒 唤醒线程池等待线程其中的一个。
notifyAll() : 唤醒线程池所有等待 线程。
wait与notify方法要注意的事项:
1. wait方法与notify方法是属于Object对象 的。
2. wait方法与notify方法必须要在同步代码块或者是同步函数中才能 使用。
3. wait方法与notify方法必需要由锁对象调用。
*/
//产品类
class Product{
String name;
double price;
boolean flag = false; //判断产品是否已生产,默认没有生产完成。
}
//生产者
class Producter extends Thread{
//1.引入产品类
Product p;
Producter(Product p){
this.p = p;
}
@Override
public void run() {
int i = 0;
while (true) {
synchronized (p) {
if(p.flag==false){
if(i%2==0){
p.name = "苹果";
p.price = 6.8;
}else {
p.name = "橡胶";
p.price = 2.0;
}
System.out.println("生产者生产出来:"+p.name+" 价格:"+p.price);
p.flag = true;
i++;
p.notifyAll();//唤醒消费者去消费,锁对象调用
}else {
//已经生产了一个了,等待消费者先去消费
try {
p.wait(); //生产者等待
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
}
}
//消费者
class Customer extends Thread{
//引入产品类
Product p;
public Customer(Product p) {
this.p = p;
}
@Override
public void run() {
while(true){
synchronized (p) {
if(p.flag){
System.out.println("消费者消费了:"+p.name+" 价格:"+p.price);
p.flag = false;//消费一下就停了
p.notifyAll();
}else {
try {//停止消费
p.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
}
}
public class ThreadDemo5 {
public static void main(String[] args){
Product p = new Product();
Producter producter = new Producter(p);
Customer customer = new Customer(p);
producter.start();
customer.start();
}
}
6.线程的停止的 两个方法
package sh.thread;
/*
* 线程的停止:
* 1.停止一个线程 我们一般都会通过一个变量去控制的。
* 2.如果需要停止一个处于等待状态下的线程,那么我们需要通过变量配合
* notify方法或者interrupt()来使用。
*notify:是唤醒它,它运行完了,自然就停止了,必须在锁对象内
*interrupt:直接把它的等待状态强制清除!
* */
public class Thread6 extends Thread{
boolean flag = true;//停止线程的标识
public Thread6(String name){
super(name);
}
//自定义一个一开始就等待的线程,来停掉它!
@Override
public synchronized void run() {
while(flag){
try {
this.wait();
} catch (InterruptedException e) {
System.out.println("已停止,且捕获异常了");
}
}
}
public static void main(String[] args) {
Thread6 t6 = new Thread6("小二");
t6.start();//开始自定义线程
for(int i=0;i<10;i++){
System.out.println(Thread.currentThread().getName()+":"+i);
if(i==8){
t6.flag = false;//让t6线程跳出循环
//停止线程方法1:唤醒它,自然停止
/*synchronized (t6) {
t6.notify();
}*/
//停止线程方法2:interrupt强制清除它的等待状态:会抛出一个异常
t6.interrupt();
}
}
}
}
7 . 守护线程详解
package sh.thread;
/*
守护线程(后台线程):在一个进程中如果只剩下 了守护线程,那么守护线程也会死亡。
//如果一个线程随着你的主线程存在就存在,随着主线程消亡就消亡,那就可以将它设置为后台线程
//守护线程:做下载更新包...
需求: 模拟QQ下载更新包。
一个线程默认都不是守护线程。
*/
public class Thread7 extends Thread {
public Thread7(String name){
super(name);
}
@Override
public void run() {
for(int i = 1 ; i<=10 ; i++){
System.out.println("更新包目前下载"+i+"%");
if(i==10){
System.out.println("更新包下载完毕,准备安装..");
}
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
public static void main(String[] args) {
Thread7 d = new Thread7("后台线程");
d.setDaemon(true); //setDaemon() 设置线程是否为守护线程,true为守护线程, false为非守护线程。
// System.out.println("是守护线程吗?"+ d.isDaemon()); //判断线程是否为守护线程。
d.start();
for(int i = 1 ; i<=10 ; i++){
System.out.println(Thread.currentThread().getName()+":"+i);
}
}
}
8 . 线程中的 join方法
package cn.itcast.thread;
/*
join方法。 加入
*/
//老妈
class Mon extends Thread{
public void run() {
System.out.println("妈妈洗菜");
System.out.println("妈妈切菜");
System.out.println("妈妈准备炒菜,发现没有酱油了..");
//叫儿子去打酱油
Son s= new Son();
s.start();
try {
s.join(); //加入。 一个线程如果执行join语句,那么就有新的线程加入,执行该语句的线程必须要让步给新加入的线程先完成任务,然后才能继续执行。
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("妈妈继续炒菜");
System.out.println("全家一起吃饭..");
}
}
class Son extends Thread{
@Override
public void run() {
System.out.println("儿子下楼..");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("儿子一直往前走");
System.out.println("儿子打完酱油了");
System.out.println("上楼,把酱油给老妈");
}
}
public class Demo8 {
public static void main(String[] args) {
Mon m = new Mon();
m.start();
}
}