java线程的典例

最新推荐文章于 2023-07-29 20:29:43 发布

Al菜菜

最新推荐文章于 2023-07-29 20:29:43 发布

阅读量594

点赞数

分类专栏： java 文章标签： java thread 线程

本文链接：https://blog.csdn.net/qq_22605739/article/details/42360623

版权

java 专栏收录该内容

9 篇文章 0 订阅

订阅专栏

<pre name="code" class="java">/**
 * 创建一个简单的线程,通过继承Thread类
 * 
 * @author Al菜菜
 *
 */
public class ThreadDemo01 extends Thread {
	private String name;

	public ThreadDemo01(String name) {
		super();
		this.name = name;
	}

	@Override
	public void run() {
		for (int i = 0; i < 1000; i++) {
			System.out.println(name + ":" + i);
		}
	}

	public static void main(String[] args) {
		ThreadDemo01 td = new ThreadDemo01("me");
		ThreadDemo01 td1 = new ThreadDemo01("you");
		td.start();
		td1.start();
	}

}

</pre><pre name="code" class="java">

</pre><pre name="code" class="java">/**
 * 通过实现Runnable接口,创建一个线程
 * 
 * @author Al菜菜
 *
 */
public class ThreadDemo02 implements Runnable {
	private String name;

	public ThreadDemo02(String name) {
		this.name = name;
	}

	public static void main(String[] args) {
		ThreadDemo02 td = new ThreadDemo02("me");
		ThreadDemo02 td1 = new ThreadDemo02("you");
		Thread th=new Thread(td);
		Thread th1=new Thread(td1);
		th.start();
		th1.start();
	}

	@Override
	public void run() {
		for (int i = 0; i < 1000; i++) {
			System.out.println(this.name + ":" + i);
		}
	}

}

/**
 * 创建线程,通过实现Runnable接口进而实现资源的共享
 * 
 * @author Al菜菜
 *
 */
public class ThreadDemo03 implements Runnable {
	private int ticket = 10;

	public static void main(String[] args) {
		ThreadDemo03 td1 = new ThreadDemo03();
		Thread t1 = new Thread(td1, "线程一");
		Thread t2 = new Thread(td1, "线程二");
		t1.start();
		t2.start();
	}

	@Override
	public void run() {
		for (int i = 1; i <= 10; i++) {
			if (ticket > 0)
				System.out.println(Thread.currentThread().getName() + ticket--);
		}
	}

}

/**
 * 判断线程是否启动
 * 
 * @author Al菜菜
 *
 */
public class ThreadDemo04 implements Runnable {
	public static void main(String[] args) {
		ThreadDemo04 td4 = new ThreadDemo04();
		Thread t1 = new Thread(td4, "线程啊");
		System.out.println(t1.isAlive() ? "线程已经启动" : "线程还未启动");
		t1.start();
		System.out.println(t1.isAlive() ? "线程已经启动" : "线程还未启动");
	}

	@Override
	public void run() {
		// TODO Auto-generated method stub
		for (int i = 0; i < 10; i++) {
			System.out.println(i);
		}
	}

}

/**
 * 线程的强制执行
 * 
 * @author Al菜菜
 *
 */
public class ThreadDemo05 {
	public static void main(String[] args) {
		Thread t1 = new Thread(new Runnable() {
			@Override
			public void run() {
				for (int i = 0; i < 1000; i++) {
					System.out.println(Thread.currentThread().getName() + ":"
							+ i);
				}
			}
		});
		t1.start();
		for (int i = 0; i < 1000; i++) {
			if (i > 10) {
				try {
					t1.join();
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
			System.out.println(Thread.currentThread().getName() + ":" + i);
		}
	}

}

/**
 * 线程的休眠
 * @author Al菜菜
 *
 */
public class ThreadDemo6 implements Runnable{
	public static void main(String[] args) {
		ThreadDemo6 t=new ThreadDemo6();
		new Thread(t).start();;
	}

	@Override
	public void run() {
		for(int i=0;i<100;i++){
			try {
				Thread.sleep(100);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			System.out.println(Thread.currentThread().getName()+":"+i);
		}
	}

}

/**
 * 线程的打断
 * 
 * @author Al菜菜
 *
 */
public class ThreadDemo07 {

	public static void main(String[] args) {
		Thread t1=new Thread(new Runnable() {
			
			@Override
			public void run() {
				try {
					Thread.sleep(10000);
				} catch (InterruptedException e) {
					System.out.println("打断");
				}
			}
		});
		t1.start();
		try {
			Thread.sleep(2000);
			t1.interrupt();
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	}

}

/**
 * 后台线程
 * @author Al菜菜
 *
 */
public class ThreadDemo08 {

	public static void main(String[] args) {
		Thread t1=new Thread(new Runnable() {
			
			@Override
			public void run() {
				while(true){
					System.out.println("后台线程");
				}
			}
		});
		t1.setDaemon(true);
		t1.start();
		
		
	}

}

/**
 * 线程的优先级
 * @author Al菜菜
 *
 */
public class ThreadDemo09 implements Runnable{
	
	public static void main(String[] args) {
		ThreadDemo09 td9=new ThreadDemo09();
		Thread t =new Thread(td9);
		Thread t1 =new Thread(td9);
		Thread t2 =new Thread(td9);
		t.setPriority(5);
		t1.setPriority(8);
		t2.setPriority(10);
		t.start();
		t1.start();
		t2.start();
	}
	@Override
	public void run() {
		for(int i=0;i<100;i++){
			System.out.println(Thread.currentThread().getName()+":"+i);
		}
	}

}

/**
 * 线程的礼让
 * @author Al菜菜
 *
 */
public class ThreadDemo10 implements Runnable{

	public static void main(String[] args) {
		ThreadDemo10 td10=new ThreadDemo10();
		Thread th=new Thread(td10);
		Thread th1=new Thread(td10);
		th.start();
		th1.start();
	}
	@Override
	public void run() {
		for(int i=0;i<100;i++){
			if(i%3==0){
				System.out.println("线程礼让");
				Thread.yield();
			}
			System.out.println(Thread.currentThread().getName()+":"+i);
		}
	}

}

/**
 * 买票问题
 * @author Al菜菜
 *
 */
public class ThreadDemo11 implements Runnable{
	private int a=10;
	public static void main(String[] args) {
		ThreadDemo11 t11 = new ThreadDemo11();
		Thread t1=new Thread(t11);
		Thread t2=new Thread(t11);
		Thread t3=new Thread(t11);
		t1.start();
		t2.start();
		t3.start();
	}

	@Override
	public void run() {
		for(int i=0;i<50;i++){
			synchronized (this) {
				if(a>0){
					try {
						Thread.sleep(200);
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
					System.out.println("a:"+a--);
				}
			}
		
		}
	}

}

/**
 * 消费者和生产者的问题(比较好的实现方法,把要生产和消费的产品利用封装的特性包装在一个类中)
 * 
 * @author Al菜菜
 *
 */
public class ThreadDemo12 {
	public static void main(String[] args) {
		goods g=new goods();
		Product pro=new Product(g);
		Thread th1=new Thread(pro);
		th1.start();
		Customer cus=new Customer(g);
		Thread th2=new Thread(cus);
		th2.start();
	}

}
/**
 * 商品类
 * @author Al菜菜
 *
 */
class goods {
	private String name;
	private int num;

	public void setName(String name) {
		this.name = name;
	}

	public String getName() {
		return name;
	}

	public void setNum(int num) {
		this.num = num;
	}

	public int getNum() {
		return num;
	}
	/**
	 * 消费后将商品设为空值
	 */
	public void setEmpty(){
		this.name=null;
		this.num=0;
	}
	/**
	 * 判断是否有商品可以消费
	 * @return
	 */
	public boolean isEmpty(){
		return this.name==null&&this.num==0;
	}
}

class Product implements Runnable {
	private boolean flag = false;//用于循环生产商品
	private goods g;

	public Product(goods g) {
		this.g = g;
	}

	@Override
	public void run() {
		for (int i = 0; i < 30; i++) {
			synchronized (Object.class) { //线程锁
				if(!g.isEmpty()){
					try {
						Object.class.wait();  //当有商品没有被消费是,进入等待状态
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
				}
				if (flag) {
					System.out.print("生产了商品一");
					g.setName("商品一");
					try {
						Thread.sleep(100); //用于在不使用锁的情况下,触发现象
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
					System.out.println("生产了20个");
					g.setNum(20);
					flag=false;
				} else {
					System.out.print("生产了商品二");
					g.setName("商品二");
					try {
						Thread.sleep(100);
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
					System.out.println("生产了40个");
					g.setNum(40);
					flag=true;
				}
				Object.class.notify();
			}
		}
	}
}

class Customer implements Runnable {
	private goods g;

	public Customer(goods g) {
		this.g = g;
	}

	@Override
	public void run() {
		for(int i=0;i<30;i++){
			synchronized (Object.class) {
				if(g.isEmpty()){
					try {
						Object.class.wait();
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
				}
				System.out.println("消费商品:"+g.getName()+"数量:"+g.getNum());
				g.setEmpty();
				Object.class.notify();
			}
		}
	}
}

/**
 * 用java线程实现死锁
 * @author Al菜菜
 *
 */
public class ThreadDemo13 implements Runnable{

	public static void main(String[] args) {
		ThreadDemo13 td13 = new ThreadDemo13();
		Thread t1=new Thread(td13);
		Thread t2=new Thread(td13);
		t1.start();
		t2.start();
	}

	@Override
	public void run() {
		synchronized (Object.class) {
			try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			synchronized (this) {
				for(int i=0;i<100;i++){
					System.out.println(Thread.currentThread().getName()+":"+i);
				}
			}
			
		}
		synchronized (this) {
			try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			synchronized (Object.class) {
				for(int i=0;i<100;i++){
					System.out.println(Thread.currentThread().getName()+":"+i);
				}
			}
			
		}
	}

}