多线程事例

来源：互联网发布：javascript读取xml 编辑：程序博客网时间：2024/04/30 11:29

1, 通过两个线程分别实现输出，一个线程输出大写 A-Z,另一个线程输出小写a-z，且交互输出(不能同步)

/**
* @Description:TODO
* @project:project
* @class:Thread1.java
* @author:
* @time:2015-7-8 下午02:44:43
*/
package thread;

/**
*
* @author:
*/
public class Thread1 {

/**
* 通过两个线程分别实现输出，一个线程输出大写 A-Z,
* 另一个线程输出小写a-z，且交互输出(不能同步)
*/
public static void main(String[] args) {
  Data data = new Data();
  Majuscule m = new Majuscule(data);
  Lowercase l = new Lowercase(data);
  m.start();
  l.start();
}

}
//创建对象的具体方法,这些东西应该在线程的run方法中，因为太长，所有独立成方法
class Data{
//打印大写字母
public void Majuscule(){
  for(char i='A'; i<='Z';i++){
   try {
    Thread.sleep(2);
    System.out.print(i+" ");
   } catch (Exception e) {
    e.printStackTrace();
   }
  }
}
//打印小写字母
public void Lowercase(){
  for(char i='a';i<='z';i++){
   try {
    Thread.sleep(2);
    System.out.print(i+" ");
   } catch (Exception e) {
    e.printStackTrace();
   }
  }
}
}

//打印大写字母的线程
class Majuscule extends Thread{
private Data data;

/**
* @Description:TODO
* @param data
* @author:
* @time:2015-7-8 下午02:58:45
*/
public Majuscule(Data data) {
super();
this.data = data;
}

public void run(){
data.Majuscule();
}
}

//打印小写字母的线程
class Lowercase extends Thread{
private Data data;

/**
* @Description:TODO
* @param data
* @author:
* @time:2015-7-8 下午03:00:45
*/
public Lowercase(Data data) {
  super();
  this.data = data;
}

public void run(){
  data.Lowercase();
}
}

2,同时启动两个线程，调用同一个类中的两个方法，分别打印出0—100和101到200之间的数字，且要求数字打印不能交互

/**
* @Description:TODO
* @project:project
* @class:Thread2.java
* @author:
* @time:2015-7-8 下午03:04:30
*/
package thread;

/**
*
* @author:
*/
public class Thread2 {

/**
* 同时启动两个线程，调用同一个类中的两个方法，分别打印出0—100和
* 101到200之间的数字，且要求数字打印不能交互
*/
public static void main(String[] args) {
  Data1 data = new Data1();
  print1 p1 = new print1(data);
  print2 p2 = new print2(data);
  p1.start();
  p2.start();
}

}

//创建对象的具体方法,这些东西应该在线程的run方法中，因为太长，所有独立成方法
class Data1{

//打印0——100
public synchronized void print1(){
  for(int i=0;i<=100;i++){
   try {
    System.out.print(i+" ");
    if(i%20 == 0){
     System.out.println();
    }
   } catch (Exception e) {
    e.printStackTrace();
   }
  }
}

//打印101——200
public synchronized void print2(){
  for(int i=101 ; i<=200; i++){
   try {
    System.out.print(i+" ");
    if(i%20 == 0){
     System.out.println();
    }
   } catch (Exception e) {
    e.printStackTrace();
   }
  }
}
}

//打印0——100的线程
class print1 extends Thread{
private Data1 data;

/**
* @Description:TODO
* @param data
* @author:
* @time:2015-7-8 下午03:14:18
*/
public print1(Data1 data) {
  super();
  this.data = data;
}

public void run(){
  data.print1();
}
}

//打印101——200的线程
class print2 extends Thread{
private Data1 data;

/**
* @Description:TODO
* @param data
* @author:
* @time:2015-7-8 下午03:15:46
*/
public print2(Data1 data) {
  super();
  this.data = data;
}

public void run(){
  data.print2();
}
}

3,设计4个线程，其中两个线程每次对j增加1，另外两个线程对j每次减少1

/**
* @Description:TODO
* @project:project
* @class:Thread3.java
* @author:
* @time:2015-7-8 下午03:26:29
*/
package thread;

/**
*
* @author:
*/
public class Thread3 {

/**
* 设计4个线程，其中两个线程每次对j增加1，另外两个线程对j每次减少1
*/
public static void main(String[] args) {
  Data2 data = new Data2();
  add a1 = new add(data);
  add a2 = new add(data);
  lessen l1 = new lessen(data);
  lessen l2 = new lessen(data);

  a1.start();
  a2.start();
  l1.start();
  l2.start();
}
}

class Data2{
int j = 1;
//增加j的方法
public synchronized void add(){
  for(int i=1; i<=20; i++){
   System.out.print(j++ +" ");
  }
  System.out.println("\n----------------------------------------------------");
}
//减少j的方法
public synchronized void lessen(){
  for(int i=1; i<=20; i++){
   System.out.print(--j + " ");
  }
  System.out.println("\n----------------------------------------------------");
}
}

//增加j的线程
class add extends Thread{
private Data2 data;

/**
* @Description:TODO
* @param data
* @author:
* @time:2015-7-8 下午03:34:32
*/
public add(Data2 data) {
  super();
  this.data = data;
}

public void run(){
  data.add();
}
}

//减少j的线程
class lessen extends Thread{
private Data2 data;

/**
* @Description:TODO
* @param data
* @author:
* @time:2015-7-8 下午03:35:27
*/
public lessen(Data2 data) {
  super();
  this.data = data;
}

public void run(){
  data.lessen();
}
}

4,编写一个线程类，启动10条线程同时执行该类，要求输出效果如下所示
　 001
     002
     003
     ….
     999
  输出001—99 每个线程要都有机会，而且不能重复而其有序

/**
* @Description:TODO
* @project:project
* @class:Thread4.java
* @author:
* @time:2015-7-8 下午03:45:55
*/
package thread;

import java.text.NumberFormat;

/**
*
* @author:
*/
public class Thread4 {

/**
* 编写一个线程类，启动10条线程同时执行该类，要求输出效果如下所示
　　  001
     002
     003
     ….
     999
  输出001—999 每个线程要都有机会，而且不能重复而其有序
*/
public static void main(String[] args) {
  rank t=new rank();
  for(int i=1; i<=10; i++){
   new Thread(t,"线程"+i).start();
  }
}
}

class rank implements Runnable {
int index = 1;

public void run() {
  while (true) {
   synchronized (this) {
    if (index == 1000){
     break;
    }else {
     try {
      Thread.sleep(2);
      NumberFormat nf = NumberFormat.getInstance();
      nf.setMinimumIntegerDigits(3);
      String s = nf.format(index++);
      System.out.println(Thread.currentThread().getName()+":"+s);
     } catch (Exception e) {
      e.printStackTrace();
     }
    }
   }
  }
}
}

5,开起两个线程同时买100张票，每个窗口随机卖票

/**
* @Description:TODO
* @project:project
* @class:ThreadTest.java
* @author:
* @time:2015-7-9 下午02:26:17
*/
package thread;

/**
*
* @author:
*/
public class Thread5_2 {

public static void main(String[] args) {
Threads1 m = new Threads1();

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

  t1.setName("窗口1");
  t1.start();
  t2.setName("窗口2");
  t2.start();
}

}

// 每个窗口随机卖票
class Threads1 extends Thread {
// 车票数量
private static int tickets = 100;

@Override
public void run() {
  while (true) {
   synchronized (this) {
    if (tickets > 0) {
     try {
      Thread.sleep(2);
      System.out.println(Thread.currentThread().getName() + "卖出第{"
        + tickets-- + "}张票");
     } catch (Exception e) {
      e.printStackTrace();
     }
    } else {
     break;
    }

}
}
}
}

0 0