java多线程编程实例

时间:2021-09-23 04:52:06

一.相关知识:

java多线程程序设计到的知识:

(一)对同一个数量进行操作

(二)对同一个对象进行操作

(三)回调方法使用

(四)线程同步,死锁问题

(五)线程通信

等等

二.示例一:三个售票窗口同时出售20张票;

程序分析:

1.票数要使用同一个静态值

2.为保证不会出现卖出同一个票数,要java多线程同步锁。

设计思路:

1.创建一个站台类station,继承thread,重写run方法,在run方法里面执行售票操作!售票要使用同步锁:即有一个站台卖这张票时,其他站台要等这张票卖完!

2.创建主方法调用类

(一)创建一个站台类,继承thread

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
package com.xykj.threadstation;
public class station extends thread {
    // 通过构造方法给线程名字赋值
    public station(string name) {
       super(name);// 给线程名字赋值
    }
    // 为了保持票数的一致,票数要静态
    static int tick = 20;
    // 创建一个静态钥匙
    static object ob = "aa";//值是任意的
    // 重写run方法,实现买票操作
    @override
    public void run() {
      while (tick > 0) {
        synchronized (ob) {// 这个很重要,必须使用一个锁,
          // 进去的人会把钥匙拿在手上,出来后才把钥匙拿让出来
          if (tick > 0) {
            system.out.println(getname() + "卖出了第" + tick + "张票");
            tick--;
          } else {
            system.out.println("票卖完了");
          }
        }
        try {
           sleep(1000);//休息一秒
        } catch (interruptedexception e) {
          e.printstacktrace();
        }
      }
  }
}

(二)创建主方法调用类

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
package com.xykj.threadstation;
public class mainclass {
  /**
   * java多线程同步锁的使用
   * 示例:三个售票窗口同时出售10张票
   * */
  public static void main(string[] args) {
    //实例化站台对象,并为每一个站台取名字
     station station1=new station("窗口1");
     station station2=new station("窗口2");
     station station3=new station("窗口3");
    // 让每一个站台对象各自开始工作
     station1.start();
     station2.start();
     station3.start();
  }
}

程序运行结果:

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
窗口1卖出了第20张票
窗口2卖出了第19张票
窗口3卖出了第18张票
窗口3卖出了第17张票
窗口1卖出了第16张票
窗口2卖出了第15张票
窗口3卖出了第14张票
窗口1卖出了第13张票
窗口2卖出了第12张票
窗口2卖出了第11张票
窗口1卖出了第10张票
窗口3卖出了第9张票
窗口3卖出了第8张票
窗口1卖出了第7张票
窗口2卖出了第6张票
窗口3卖出了第5张票
窗口1卖出了第4张票
窗口2卖出了第3张票
窗口3卖出了第2张票
窗口1卖出了第1张票
票卖完了

可以看到票数是不会有错的!

三.示例二:两个人ab通过一个账户a在柜台取钱和b在atm机取钱!

程序分析:钱的数量要设置成一个静态的变量。两个人要取的同一个对象值

(一)创建一个bank类

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
package com.xykj.bank;
public class bank {
  // 假设一个账户有1000块钱
  static int money = 1000;
  // 柜台counter取钱的方法
  public void counter(int money) {// 参数是每次取走的钱
    bank.money -= money;//取钱后总数减少
    system.out.println("a取走了" + money + "还剩下" + (bank.money));
  }
  // atm取钱的方法
  public void atm(int money) {// 参数是每次取走的钱
    bank.money -= money;//取钱后总数减少
    system.out.println("b取走了" + money + "还剩下" + (bank.money));
  }
}

(二)创建一个persona类

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
package com.xykj.bank;
public class persona extends thread {
  // 创建银行对象
  bank bank;
  // 通过构造器传入银行对象,确保两个人进入的是一个银行
  public persona(bank bank) {
     this.bank = bank;
  }
  //重写run方法,在里面实现使用柜台取钱
  @override
    public void run() {
      while (bank.money >= 100) {
        bank.counter(100);// 每次取100块
      try {
        sleep(100);// 取完休息0.1秒
      } catch (interruptedexception e) {
        e.printstacktrace();
      }
    }
  }
}

(三)创建一个personb类

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
package com.xykj.bank;
public class personb extends thread {
  // 创建银行对象
  bank bank;
  // 通过构造器传入银行对象,确保两个人进入的是一个银行
  public personb(bank bank) {
    this.bank = bank;
  }
  // 重写run方法,在里面实现使用柜台取钱
  @override
  public void run() {
    while (bank.money >= 200) {
      bank.atm(200);// 每次取200块
      try {
        sleep(100);// 取完休息0.1秒
      } catch (interruptedexception e) {
        e.printstacktrace();
      }
    }
  }
}

(四)创建主方法的调用类

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
package com.xykj.bank;
public class mainclass {
  /**
   * 两个人ab通过一个账户a在柜台取钱和b在atm机取钱
   * */
  public static void main(string[] args) {
    // 实力化一个银行对象
    bank bank = new bank();
    // 实例化两个人,传入同一个银行的对象
    persona pa = new persona(bank);
    personb pb = new personb(bank);
    // 两个人开始取钱
    pa.start();
    pb.start();
  }
}

运行结果:

java多线程编程实例

可以看到取完就停止运行了。

四.示例三:龟兔赛跑问题

龟兔赛跑:20米//只要为了看到效果,所有距离缩短了

要求:

1.兔子每秒0.5米的速度,每跑2米休息10秒,

2.乌龟每秒跑0.1米,不休息

3.其中一个跑到终点后另一个不跑了!

程序设计思路:

1.创建一个animal动物类,继承thread,编写一个running抽象方法,重写run方法,把running方法在run方法里面调用。

2.创建rabbit兔子类和tortoise乌龟类,继承动物类

3.两个子类重写running方法

4.本题的第3个要求涉及到线程回调。需要在动物类创建一个回调接口,创建一个回调对象

(一)创建animal动物类

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
package com.xykj.rabbit_tortoise;
public abstract class animal extends thread{
  public double length=20;//比赛的长度
  public abstract void runing();//抽象方法需要子类实现
  //在父类重写run方法,在子类只要重写running方法就可以了
  @override
  public void run() {
    super.run();
    while (length>0) {
       runing();
    }
  }
  //在需要回调数据的地方(两个子类需要),声明一个接口
  public static interface calltoback{
    public void win();
  }
  //2.创建接口对象
  public calltoback calltoback;
}

(二)创建rabbit兔子类

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
package com.xykj.rabbit_tortoise;
public class rabbit extends animal {
  public rabbit() {
    setname("兔子");// thread的方法,给线程赋值名字
  }
  // 重写running方法,编写兔子的奔跑操作
  @override
  public void runing() {
    // 跑的距离
    double dis = 0.5;
    length -= dis;//跑完后距离减少
    if (length <= 0) {
      length = 0;
      system.out.println("兔子获得了胜利");
      //给回调对象赋值,让乌龟不要再跑了
      if (calltoback != null) {
        calltoback.win();
      }
    }
    system.out.println("兔子跑了" + dis + "米,距离终点还有" + (int)length + "米");
    if (length % 2 == 0) {// 两米休息一次
      try {
        sleep(1000);
      } catch (interruptedexception e) {
        e.printstacktrace();
      }
    }
  }
}

(三)创建tortoise乌龟类

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
package com.xykj.rabbit_tortoise;
public class tortoise extends animal {
  public tortoise() {
    setname("乌龟");// thread的方法,给线程赋值名字
  }
  // 重写running方法,编写乌龟的奔跑操作
  @override
  public void runing() {
    // 跑的距离
    double dis = 0.1;
    length -= dis;
    if (length <= 0) {
      length = 0;
      system.out.println("乌龟获得了胜利");
      // 让兔子不要在跑了
      if (calltoback != null) {
        calltoback.win();
      }
    }
    system.out.println("乌龟跑了" + dis + "米,距离终点还有" + (int) length + "米");
    try {
      sleep(100);
    } catch (interruptedexception e) {
      e.printstacktrace();
    }
  }
}

(四)创建一个让动物线程停止的类,这里要实现回调接口

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
package com.xykj.rabbit_tortoise;
import com.xykj.rabbit_tortoise.animal.calltoback;
public class letonestop implements calltoback {
  // 动物对象
  animal an;
  // 获取动物对象,可以传入兔子或乌龟的实例
  public letonestop(animal an) {
    this.an = an;
  }
  //让动物的线程停止
  @override
  public void win() {
    // 线程停止
    an.stop();
  }
}

(五)创建一个主方法调用类,

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
package com.xykj.rabbit_tortoise;
public class mainclass {
  /**
   * 龟兔赛跑:20米  
   * */
  public static void main(string[] args) {
    //实例化乌龟和兔子
    tortoise tortoise = new tortoise();
    rabbit rabbit = new rabbit();
    //回调方法的使用,谁先调用calltoback方法,另一个就不跑了
    letonestop letonestop1 = new letonestop(tortoise);
    rabbit.calltoback = letonestop1;//让兔子的回调方法里面存在乌龟对象的值,可以把乌龟stop
    letonestop letonestop2 = new letonestop(rabbit);
    tortoise.calltoback = letonestop2;//让乌龟的回调方法里面存在兔子对象的值,可以把兔子stop
    //开始跑
    tortoise.start();
    rabbit.start();
  }
}

运行结果:

java多线程编程实例

可以看到结果兔子赢了。

一般来说兔子获得了胜利是在最后输出的,

但是,由于线程一直在执行所以会出现:

“兔子跑了0.5米,距离终点还有0米”还没来得及输出完,

而“兔子获得了胜利”已经输出完毕了。

五.实例四:

在一个kfc内,服务员负责生产食物,消费者负责消费食物;

当生产到一定数量可以休息一下,直到消费完食物,再马上生产,一直循环

程序涉及到的内容:

1.这设计到java模式思想:生产者消费者模式

2.要保证操作对象的统一性,即消费者和服务者都是跟同一个kfc发生关系的,kfc只能new一次

3.this.notifyall();和this.wait();一个是所有唤醒的意思,一个是让自己等待的意思;

比如本题中,生产者生产完毕后,先所有唤醒(包括消费者和生产者),再让所有自己(生产者)等待

这时,消费者开始消费,直到食材不够,先所有唤醒(包括消费者和生产者),再让所有自己(消费者)等待

一直执行上面的操作的循环

4.生产者和消费者都要继承thread,才能实现多线程的启动

程序设计的步骤思路:

1.创建一个食物类food,有存放/获取食物的名称的方法

2.创建一个kfc类,有生产食物和消费食物的方法

3.创建一个客户类customer,继承thread,重写run方法,在run方法里面进行消费食物操作

4.创建一个服务员类waiter,继承thread,重写run方法,在run方法里面进行生产食物的操作

5.创建主方法的调用类

(一)创建一个食物类food

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
package com.xykj.producer_consumer;
public class food {
  string name="";
  //通过构造方法传入食物的名字
  public food(string name) {
    this.name=name;
  }
  //get、set 方法
  public string getname() {
    return name;
  }
  public void setname(string name) {
    this.name = name;
  }
}

(二)创建一个kfc类

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
package com.xykj.producer_consumer;
import java.util.arraylist;
import java.util.list;
public class kfc {
  //食物的种类
  string[] names = { "薯条", "烧板", "鸡翅", "可乐" };
  //生产的最大值,到达后可以休息
  static final int max = 20;
  //存放食物的集合
  list<food> foods = new arraylist<food>();
  // 生产食物的方法
  public void prod(int index) {
    synchronized (this) {
      // 如果食物数量大于20
      while (foods.size() > max) {
        system.out.println("食材够了");
        this.notifyall();//这个唤醒是针对生产者和消费者,有all
        try {
          string name=thread.currentthread().getname();
          this.wait();//这个唤醒是针对生产者,没有all
          system.out.println("生产者:"+name);
        } catch (interruptedexception e) {
          e.printstacktrace();
        }
      }
      // 开始生产食物食物//有一点要注意的
      system.out.println("开始生产食物");
      for (int i = 0; i < index; i++) {
        food food = new food(names[(int) (math.random() * 4)]);
        foods.add(food);
        system.out.println("生产了" + food.getname() + foods.size());
      }
    }
  }
  // 消费食物的方法
  public void consu(int index) {
    synchronized (this) {
      while (foods.size() < index) {
        system.out.println("食材不够了");
        this.notifyall();//这个唤醒是针对生产者和消费者,有all
        try {
          string name=thread.currentthread().getname();
          this.wait();//这个唤醒是针对消费者,没有all
          system.out.println("消费者:"+name);
        } catch (interruptedexception e) {
          e.printstacktrace();
        }
      }
      // 足够消费
      system.out.println("开始消费");
      for (int i = 0; i < index; i++) {
        food food = foods.remove(foods.size() - 1);
        system.out.println("消费了一个" + food.getname() + foods.size());
      }
    }
  }
}

(三)创建一个客户类customer

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
package com.xykj.producer_consumer;
public class customers extends thread{
  kfc kfc;
  //kfc要传入,保证每一个服务员和用户在同一个kfc对象内
  public customers(kfc kfc) {
    this.kfc=kfc;
  }
  @override
  public void run() {
    int size=(int)(math.random()*5);//每次要消费的食物的数量
    while (true) {
      kfc.consu(size);//在消费的方法里面传入参数
    }
  }
}

(四)创建一个服务员类waiter

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
package com.xykj.producer_consumer;
public class waiter extends thread{
  kfc kfc;
  //kfc要传入,保证每一个服务员和用户在同一个kfc对象内
  public waiter(kfc kfc) {
    this.kfc=kfc;
  }
  @override
  public void run() {
    int size=(int)(math.random()*5)+5;//每次生产的数量
    while (true) {
      kfc.prod(size);//传入每次生产的数量
    }
  }
}

(五)创建主方法的调用类

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
package com.xykj.producer_consumer;
public class mainclass {
  /**
   * 生产者消费者模式
   *
   * */
  public static void main(string[] args) {
    // 只实例化一个kfc对象,保证每一个服务员和用户在同一个kfc对象内
    kfc kfc = new kfc();
    //实例化4个客户对象
    customers c1 = new customers(kfc);
    customers c2 = new customers(kfc);
    customers c3 = new customers(kfc);
    customers c4 = new customers(kfc);
    //实例化3个服务员对象
    waiter waiter1 = new waiter(kfc);
    waiter waiter2 = new waiter(kfc);
    waiter waiter3 = new waiter(kfc);
    //让所有的对象的线程都开始工作
    waiter1.start();
    waiter2.start();
    waiter3.start();
    c1.start();
    c2.start();
    c3.start();
    c4.start();
  }
}

六.示例五:设计四个线程对象对同一个数据进行操作

两个线程执行减操作,两个线程执行加操作。

程序分析:

1.创建一个threadaddsub类继承thread,重写run方法

2.在run方法里面实现加和减的操作,每次操作后睡眠1秒

3.创建主方法调用类

(一)创建一个threadaddsub类

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
package com.xykj.add;
public class threadaddsub extends thread {
  //判断要进行的操作
  boolean operate = true;
  //要操作的数
  static int sum = 0;
  // 把操作运算通过构造方法传进来
  public threadaddsub(boolean operate) {
    super();
    this.operate = operate;
  }
  @override
  public void run() {
    super.run();
    while (true) {
      if (operate) {
        sum+=5;
        system.out.println("加后,sum="+sum);
      } else {
        sum-=4;
        system.out.println("减后,sum="+sum);
      }
      try {
        sleep(500);// 睡眠0.5秒
      } catch (interruptedexception e) {
        e.printstacktrace();
      }
    }
  }
}

(二)创建主方法调用类

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
emptypackage com.xykj.add;
public class mainclass {
  /**
   * (线程同步)
   * */
  public static void main(string[] args) {
    //创建一个存放threadaddsub对象的数组
    threadaddsub[] tsub=new threadaddsub[4];
    for (int i = 0; i < tsub.length; i++) {
    //把实例化threadaddsub对象赋值到数组内
    //第一三个是true,二四个是false
    tsub[i]=new threadaddsub(i%2==0?true:false);
    //让线程开始工作
    tsub[i].start();
    }
  }
}

线程示例总结:

代码块锁是一个防止数据发生错误的一个重要手段。

对象的统一性是非常重要的,这要想到对象的传入问题,

要操作的对象只能new一次,其他的操作都是对这个传入的对象进行的,

才能保证数据一致性,完整性和正确性。

练习题目:

1.(多线程)代码实现火车站4个卖票窗口同时买票的场景,输出示例:

窗口1卖票

窗口2卖票

窗口1卖票

...

2.(线程同步)代码实现火车站4个窗口同时卖100张票的代码逻辑,同一个窗口不能卖同一

张张票。

3.(线程通信)小明打算去提款机上取钱,发现卡上没钱,这时候他告知妈妈去存钱,妈妈

存了钱了,告知小明存好了可以取钱了。(ps:小明分多次取钱,每次取100,当发现钱不够

100,就等待妈妈存钱,小明他妈每次存2000,当发现钱小于100就存钱,就存钱,并且

通知小明去取钱,当大于100就等待小明钱不够是再存)

4.(线程同步)设计四个线程对象对同一个数据进行操作,两个线程执行减操作,两个线程执行

加操作。

5.(线程通信)制作两个线程对象,要求用同步块的方式使第一个线程运行2次,然后将自己

阻塞起来,唤醒第二个线程,第二个线程再运行2次,然后将自己阻塞起来,唤醒第一个线

程……两个线程交替执行。

6.(线程同步)设计4个线程,其中两个线程每次对j增加1,另外两个线程对j每次减少1。

7.(线程通信)子线程循环10次,接着主线程循环100,接着又回到子线程循环10次,接着

再回到主线程又循环100,如此循环50次。

总结

以上就是本文关于java多线程编程实例的全部内容,希望对大家学习java有所帮助,有什么问题可以随时留言,小编会及时回复大家的。感谢朋友们对本站的支持!

原文链接:http://blog.csdn.net/wenzhi20102321/article/details/52524545