java多线程

最新推荐文章于 2025-02-14 15:44:02 发布

堤岸小跑hi

最新推荐文章于 2025-02-14 15:44:02 发布

阅读量597

点赞数

本文链接：https://blog.csdn.net/shuiyuehaha/article/details/9392671

版权

在java中要想实现多线程，有两种手段，一种是继续Thread类，另外一种是实现Runable接口。

package com.zb.test.duoxiancheng;
//在java中要想实现多线程，有两种手段，一种是继续Thread类，另外一种是实现Runable接口。

//对于直接继承Thread的类来说，代码大致框架是：
/**
 *  继承thread类，直接调用该类的Start方法。
 * 
 */
public class TestThread  extends Thread{
	private String name;
    
	   public TestThread() {
		 
	    }
	 
	    public TestThread(String name) {
	        this.name =name;
	    }
	 
	    //重写Tread类的run方法
	    public void run() {
	        for (int i = 0; i < 5; i++) {
	            System.out.println(name + "运行     " + i);
	        }
	    }
	
	 
	
	public static void main(String[] args) {
		
		TestThread t1= new TestThread("A");
		TestThread t2= new TestThread("B");
	    // t1.run();
	     //t2.run();   //顺序执行
		t1.start();
		t2.start();
		
	
	}

}

//通过实现Runnable接口实现

package com.zb.test.duoxiancheng;

/**
 * 
 * @author zb 实现Runnable接口，
 *
 */
public class TestRunnable implements Runnable {
   
	private String name;
	private int a=9;
	public TestRunnable(){};
	public TestRunnable(String name){
		
		this.name=name;
		
	}
	
	public static void main(String[] args) {
		
		//new Thread(new TestRunnable("1号"),"汽车").start();
		//new Thread(new TestRunnable("2号"),"火车").start();
		
		//通过下面代码可以实现资源的共享。
		TestRunnable t1 = new TestRunnable();
        new Thread(t1,"A").start();
        new Thread(t1,"B").start();
        new Thread(t1).start();
	}

	//汽车，火车即为自定义的县城名字，如果我们没有指定名字的话，系统自动提供名字。Thread-0 Thread-1
	public void run() {
		for(int i=0;i<5;i++){
		System.out.println(name+Thread.currentThread().getName()+"运行中"+i+"//"+a--);
		}
	}

}

实现Runnable接口比继承Thread类所具有的优势：

1）：适合多个相同的程序代码的线程去处理同一个资源

2）：可以避免java中的单继承的限制

3）：增加程序的健壮性，代码可以被多个线程共享，代码和数据独立。

1.判断线程是否启动

package com.zb.test.duoxiancheng;

public class TestAlive implements Runnable {

	/**
	 * @author zb 判断线程的是否启动
	 */
	public static void main(String[] args) {
		
		TestAlive ta = new TestAlive();
		Thread t1= new Thread(ta,"自定义线程");
		System.out.println("自定义线程启动前"+t1.isAlive());
		t1.start();
		System.out.println("线程启动后"+t1.isAlive());
	
	}

	@Override
	public void run() {
		for(int i=0;i<3;i++){
			System.out.println(Thread.currentThread().getName()+"在运行");
			
		}
		
	}

}

自定义线程启动前false
自定义线程在运行
自定义线程在运行
自定义线程在运行
线程启动后true

2.线程的强制执行

package com.zb.test.duoxiancheng;

public class TestJoin implements Runnable {
	/**
	 * @author zb 线程的强制启动
	 * 
	 * 
	 * join方法的应用join方法的功能就是使异步执行的线程变成同步执行。
	 * 也就是说，当调用线程实例的start方法后，这个方法会立即返回，
	 * 如果在调用start方法后后需要使用一个由这个线程计算得到的值，就必须使用join方法
	 * 。如果不使用join方法，就不能保证当执行到start方法后面的某条语句时，这个线程一定会执行完。
	 * 而使用join方法后，直到这个线程退出，程序才会往下执行
	 */
	public static void main(String[] args) {
		
		TestAlive ta = new TestAlive();
		Thread t1= new Thread(ta,"自定义线程1");
		Thread t2= new Thread(ta,"自定义线程2");
		t1.start();
		t2.start();
	for(int i=0;i<50;i++){
		if(i>10){
			try {
				t1.join();///当前线程等待t1执行完成，注意这是指main线程会等待t1执行完成以后才执行后面的代码。这里与t2毫无关系，所以t2当然不会等待，等待的只是main线程。
			} catch (InterruptedException e) {
				
				e.printStackTrace();
			}
			System.out.println("main线程在运行"+i);
			
		}
		
		
	}
		
	
	}

	@Override
	public void run() {
		for(int i=0;i<3;i++){
			System.out.println(Thread.currentThread().getName()+"在运行");
			
		}
		
	}


}

自定义线程1在运行
自定义线程1在运行
自定义线程1在运行
自定义线程2在运行
main线程在运行11
自定义线程2在运行
自定义线程2在运行
main线程在运行12
main线程在运行13
main线程在运行14
main线程在运行15
main线程在运行16
main线程在运行17
main线程在运行18
main线程在运行19
main线程在运行20
main线程在运行21
main线程在运行22
main线程在运行23
main线程在运行24
main线程在运行25
main线程在运行26
main线程在运行27
main线程在运行28
main线程在运行29
main线程在运行30
main线程在运行31
main线程在运行32
main线程在运行33
main线程在运行34
main线程在运行35
main线程在运行36
main线程在运行37
main线程在运行38
main线程在运行39
main线程在运行40
main线程在运行41
main线程在运行42
main线程在运行43
main线程在运行44
main线程在运行45
main线程在运行46
main线程在运行47
main线程在运行48
main线程在运行49

3.线程的休眠：

package com.zb.test.duoxiancheng;

public class TestSleep implements Runnable {

public static void main(String[] args) {
		
	TestSleep ta = new TestSleep();
		Thread t1= new Thread(ta,"线程");
		
		t1.start();
		
	
		
		
	
		
	
	}

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

}

每隔两秒钟打印出一条语句
线程0
线程1
线程2

线程的同步synchronzied

package com.zb.test.duoxiancheng;
/**
 * 
 * Java语言的关键字，当它用来修饰一个方法或者一个代码块的时候，能够保证在同一时刻最多只有一个线程执行该段代码。

     一、当两个并发线程访问同一个对象object中的这个synchronized(this)同步代码块时，一个时间内只能有一个线程得到执行。另一个线程必须等待当前线程执行完这个代码块以后才能执行该代码块。

     二、然而，当一个线程访问object的一个synchronized(this)同步代码块时，另一个线程仍然可以访问该object中的非synchronized(this)同步代码块。

     三、尤其关键的是，当一个线程访问object的一个synchronized(this)同步代码块时，其他线程对object中所有其它synchronized(this)同步代码块的访问将被阻塞。

     四、第三个例子同样适用其它同步代码块。也就是说，当一个线程访问object的一个synchronized(this)同步代码块时，它就获得了这个object的对象锁。结果，其它线程对该object对象所有同步代码部分的访问都被暂时阻塞。

     五、以上规则对其它对象锁同样适用.
 * 
 * 
 * 
 * @author zb  synchronized代码块
 *
 */
public class TestSyncronized implements Runnable {
	private int count=5;

	   public void run() {
	        for(int i=0;i<10;++i){
	        	synchronized (this) {
	        		 if(count>0){
	 	                try{
	 	                    Thread.sleep(1000);
	 	                }catch(InterruptedException e){
	 	                    e.printStackTrace();
	 	                }
	 	                System.out.println(count--);
	 	            }
				}
	           
	        }
	    }
	 
	    public static void main(String[] args) {
	    	TestSyncronized he=new TestSyncronized();
	        Thread h1=new Thread(he);
	        Thread h2=new Thread(he);
	        Thread h3=new Thread(he);
	        h1.start();
	        h2.start();
	        h3.start();
	    }

	

}

每隔1s打印出一个数字，不加synchronized会出现票数为-1的情况
5
4
3
2
1