java线程的简单例子(Thread and runnable)

最新推荐文章于 2024-08-15 14:47:41 发布
最新推荐文章于 2024-08-15 14:47:41 发布
阅读量720 收藏
点赞数
分类专栏： JAVA 文章标签： thread java string class 多线程 null
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/caolaosanahnu/article/details/7384433
版权

http://interper56-sohu-com.iteye.com/blog/172303

其实要了解java多线程只需要理解以下几个事情：
1) java.lang.Thraed类
2) java.lang.Runnable接口
3) synchronized关键字
4) wait(),.notify(), notifyAll();

That’s all.

[java.util.Thread类]
Jdk的线程实现类，只要继承这个类那么我们就可以实现自己的线程。
如果你想要继承这个类，主要需要重载run方法。

例如：
Java代码 复制代码  收藏代码
  1. Pubilc class MyThread {   
  2.     Pubilc MyThread() {   
  3.         Super();   
  4.     }   
  5.   
  6.     Public void run() {   
  7.         System.out.println(“Hello world”);   
  8.     }   
  9. }  
Pubilc class MyThread {
	Pubilc MyThread() {
		Super();
	}

	Public void run() {
		System.out.println(“Hello world”);
	}
}


当你要是用它的时候
Java代码 复制代码  收藏代码
  1. Publi class ThreadTest {   
  2.     Public static void main(String[] args)  {   
  3.         MyThread app = new MyThread();   
  4.         App.start();   
  5.     }   
  6. }  
Publi class ThreadTest {
	Public static void main(String[] args)  {
		MyThread app = new MyThread();
		App.start();
	}
}


当你运行这个方法的时候，就会打出Hello world.

[java.lang.Runnable接口]
因为继承Thread类就无法继承别的你想要变为线程的类，
所以java.lang.Runnable接口可以实现你的愿望

那么看下面的例子：
食物类：
Java代码 复制代码  收藏代码
  1. public class Food {   
  2.     private int foodNum = 0;   
  3.   
  4.     public Food(int foodNum) {   
  5.         this.foodNum = foodNum;   
  6.     }   
  7.        
  8.     public void setFoodNum(int foodNum) {   
  9.         this.foodNum = foodNum;   
  10.     }   
  11.        
  12.     public int getFoodNum() {   
  13.         return this.foodNum;   
  14.     }   
  15. }  
public class Food {
	private int foodNum = 0;

	public Food(int foodNum) {
		this.foodNum = foodNum;
	}
	
	public void setFoodNum(int foodNum) {
		this.foodNum = foodNum;
	}
	
	public int getFoodNum() {
		return this.foodNum;
	}
}

消费者类：
Java代码 复制代码  收藏代码
  1. public class Customer {   
  2.     private String name = "";   
  3.   
  4.     public Customer(String name) {   
  5.         this.setName(name);   
  6.     }   
  7.   
  8.     protected void setName(String name) {   
  9.         this.name = name;   
  10.     }   
  11.   
  12.     protected String getName() {   
  13.         return this.name;   
  14.     }   
  15. }  
public class Customer {
	private String name = "";

	public Customer(String name) {
		this.setName(name);
	}

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

	protected String getName() {
		return this.name;
	}
}

消费者线程类：
Java代码 复制代码  收藏代码
  1. public class CustomerThread extends Customer implements Runnable {   
  2.   
  3.     private Food food = null;   
  4.   
  5.     public CustomerThread(Food food) {   
  6.         super("Customer");   
  7.         this.food = food;   
  8.     }   
  9.   
  10.     public void run() {   
  11.         this.consume();   
  12.     }   
  13.        
  14.     public void startConsume() {   
  15.         Thread thread = new Thread(this);   
  16.         thread.start();   
  17.     }   
  18.   
  19.     private void consume() {   
  20.         int num = this.food.getFoodNum();   
  21.         num++;   
  22.         this.food.setFoodNum(num);   
  23.         System.out.println(this.getName() + " " + "consume food");   
  24.     }   
  25. }  
public class CustomerThread extends Customer implements Runnable {

	private Food food = null;

	public CustomerThread(Food food) {
		super("Customer");
		this.food = food;
	}

	public void run() {
		this.consume();
	}
	
	public void startConsume() {
		Thread thread = new Thread(this);
		thread.start();
	}

	private void consume() {
		int num = this.food.getFoodNum();
		num++;
		this.food.setFoodNum(num);
		System.out.println(this.getName() + " " + "consume food");
	}
}

生产者类：
Java代码 复制代码  收藏代码
  1. public class Productor {   
  2.     private String name = "";   
  3.   
  4.     public Productor(String name) {   
  5.         this.name = name;   
  6.     }   
  7.   
  8.     protected void setName(String name) {   
  9.         this.name = name;   
  10.     }   
  11.   
  12.     protected String getName() {   
  13.         return this.name;   
  14.     }   
  15. }  
public class Productor {
	private String name = "";

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

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

	protected String getName() {
		return this.name;
	}
}

消费者类：
Java代码 复制代码  收藏代码
  1. public class ProductorThread extends Productor implements Runnable {   
  2.   
  3.     private Food food = null;   
  4.        
  5.     public ProductorThread(Food food) {   
  6.         super("Productor");   
  7.         this.food = food;   
  8.     }   
  9.   
  10.        
  11.     public void run() {   
  12.         this.increase();   
  13.     }   
  14.        
  15.     public void startIncrease() {   
  16.         Thread thread = new Thread(this);   
  17.         thread.start();   
  18.     }   
  19.   
  20.     private void increase() {   
  21.         int num = this.food.getFoodNum();   
  22.         num--;   
  23.         this.food.setFoodNum(num);   
  24.         System.out.println(this.getName() + " " + "increase food");   
  25.     }   
  26. }  
public class ProductorThread extends Productor implements Runnable {

	private Food food = null;
	
	public ProductorThread(Food food) {
		super("Productor");
		this.food = food;
	}

	
	public void run() {
		this.increase();
	}
	
	public void startIncrease() {
		Thread thread = new Thread(this);
		thread.start();
	}

	private void increase() {
		int num = this.food.getFoodNum();
		num--;
		this.food.setFoodNum(num);
		System.out.println(this.getName() + " " + "increase food");
	}
}


测试类：
Java代码 复制代码  收藏代码
  1. public class MainTest {   
  2.     public static void main(String[] args) {   
  3.         Food food = new Food(0);   
  4.         ProductorThread productor = new ProductorThread(food);   
  5.         productor.startIncrease();   
  6.         CustomerThread customer = new CustomerThread(food);   
  7.         customer.startConsume();   
  8.     }   
  9. }  
public class MainTest {
	public static void main(String[] args) {
		Food food = new Food(0);
		ProductorThread productor = new ProductorThread(food);
		productor.startIncrease();
		CustomerThread customer = new CustomerThread(food);
		customer.startConsume();
	}
}


上面代码主要模拟了生产者和消费者生产食物，消费食物的过程，
这里面先让生产者生产了1个食物，然后让消费者消费了1个食物。

主要是想说明我们自己实现的Runnable接口的类必须借助Thread类
才可以把它变成一个线程，如果不借助Thread类，即使我们实现了run()方法，
这个类的对象也不会是一个线程。
说白了，就是用Thread(Runnable thread)这个构造方法把我们实现的Runnable
街口的类传入，然后通过Thread的start方法，来调用我们的run方法，其实
我们实现的Runnable接口的类要想变为线程，是要通过Thread这个载体来实现。

但是上面的实现存在一个问题，我们并不能保证同一时间内只有一个
CustomerThread线程在消费，不能保证在同一时间只有一个ProductorThread
线程在生产。

所以我们引入了synchronized关键字

[synchronized关键字]
通过在CustomerThraed的consume方法和ProductorThread的increase
方法前面加入synchronized关键字就可以解决上面所说的问题。
改动后的方法为：
Java代码 复制代码  收藏代码
  1. private synchronized void consume() {   
  2.     int num = this.food.getFoodNum();   
  3.     num++;   
  4.     this.food.setFoodNum(num);   
  5.     System.out.println(this.getName() + " " + "consume food");   
  6. }   
  7. private synchronized void increase() {   
  8.     int num = this.food.getFoodNum();   
  9.     num--;   
  10.     this.food.setFoodNum(num);   
  11.     System.out.println(this.getName() + " " + "increase food");   
  12. }  
	private synchronized void consume() {
		int num = this.food.getFoodNum();
		num++;
		this.food.setFoodNum(num);
		System.out.println(this.getName() + " " + "consume food");
	}
	private synchronized void increase() {
		int num = this.food.getFoodNum();
		num--;
		this.food.setFoodNum(num);
		System.out.println(this.getName() + " " + "increase food");
	}

那么synchronized关键字到底是干什么用的呢？

就是进入到synchronized关键字所包含的代码块的线程
都会尝试获得对象的锁，等拿到对象的锁后就可以进去执行代码，
如果得不到，就在那里阻塞，等待其它线程释放锁，那么怎么用呢？

1)在方法前用synchronized关键字，如下：
Java代码 复制代码  收藏代码
  1. private synchronized void consume() {   
  2.     int num = this.food.getFoodNum();   
  3.     num++;   
  4.     this.food.setFoodNum(num);   
  5.     System.out.println(this.getName() + " " + "consume food");   
  6. }  
	private synchronized void consume() {
		int num = this.food.getFoodNum();
		num++;
		this.food.setFoodNum(num);
		System.out.println(this.getName() + " " + "consume food");
	}


当线程进入到这个方法的时候，这个线程就会获得这个方法所在对象的锁，
那么其他的进程想要进入这个方法，首先尝试去获得这个方法所在对象的锁，
但是已经被前一个线程霸占了，所只能等待，当前一个线程把这段代码执行
完毕，那么后来的线程就可以获得这个对象锁了，当然它进去后又会把后面的
线程阻塞在外面等待。
这种方法等同于：
Java代码 复制代码  收藏代码
  1. private void consume() {   
  2.     synchronized(this) {   
  3.         int num = this.food.getFoodNum();   
  4.         num++;   
  5.         this.food.setFoodNum(num);   
  6.         System.out.println(this.getName() + " " + "consume food");   
  7.     }   
  8. }  
	private void consume() {
		synchronized(this) {
			int num = this.food.getFoodNum();
			num++;
			this.food.setFoodNum(num);
			System.out.println(this.getName() + " " + "consume food");
		}
	}


但是这种方法我们把整个对象都锁住了，其他线程想要执行这个类中的其它用
Synchronized方法声明的方法都不可以了，因为想要进入其它的synchronized
方法也要先获得这个对象的锁，所以这种方法比较霸道，我们不建议这么做，
所以出现了第二种方法。
2)声明一个临时的对象，让进入同一个方法的线程去获得这个临时对象的锁，
  那么获得这个临时对象的锁，并不是整个对象的锁，所以并不会锁住整个对象，
  当然也就避免了上面第一种所遇到的问题：
Java代码 复制代码  收藏代码
  1. private void consume() {   
  2.     Object lock = new Object();   
  3.     synchronized(lock) {   
  4.         int num = this.food.getFoodNum();   
  5.         num++;   
  6.         this.food.setFoodNum(num);   
  7.         System.out.println(this.getName() + " " + "consume food");   
  8.     }   
  9. }  
	private void consume() {
		Object lock = new Object();
		synchronized(lock) {
			int num = this.food.getFoodNum();
			num++;
			this.food.setFoodNum(num);
			System.out.println(this.getName() + " " + "consume food");
		}
	}

Obj是一个临时的对象，当多个线程进入到这个方法的时候都会尝试去获得这个
Obj对象的锁，谁先获得，谁就可以继续执行，否则阻塞在外面，等待前一个进程
结束执行synchronized内的代码，出了synchronized包含的代码块之后，
会马上自动释放对这个obj对象的锁。

[wait(), notify()和notifyAll()]
其实采用了上面的synchronized关键字之后，上面的代码还是有问题，
什么问题？
我们再来仔细分析一下Synchronzied关键字，
Synchronzied关键字对线程来说就是这么一回事：
1) 线程进入synchronized代码块：尝试获得对象锁
2) 线程出了synchronized代码块：释放对象锁
说白了，就是谁有锁，谁就可以继续干活，没有就得等。
加锁就是限制同一时间有多个线程同时去访问公共的资源。

但是问题也就来了，synchronized可以限制对公共的资源访问，
但是无法决定线程访问公共资源的顺序，所以引入了wait(),
Notify(), notifyAll 等原语来控制线程访问的顺序。
注意这3个原语是当前对象的方法，不是当前线程的方法。

那么让我们来看看这三个原语有什么用：
1) wait(): 使当前线程阻塞，释放它所获得的对象的锁
2) notify(): 通知虚拟机当前线程准备要释放它所获得的对象的锁，
               当调用了wait()方法或者当这个线程出了synchronized
               代码块之后，这两个动作就是释放了当前线程对对象的锁的持有，
               那么其它的被阻塞的线程又可以执行了。
3) notify(): 跟notify()没有什么大区别，notify是通知1个被阻塞的线程做准备，
               notifyAll()是通知所有被阻塞的线程做准备，至于哪个线程可以获得
               这个锁，那就看JVM的啦！

所以对于上面的生产者与消费者的例子，
正确的流程是，
如果消费者有东西可以消费，那么我们就让他消费，
如果还需要生产，还可以生产，那么我们就让生产者生产，
只需要修改CustomerThread类ProductorThread类，
Food类 MainTest类。
那么我们的最终代码如下：
CustomerThread类：
Java代码 复制代码  收藏代码
  1. public class CustomerThread extends Customer implements Runnable {   
  2.   
  3.     private Food food = null;   
  4.   
  5.     public CustomerThread(Food food) {   
  6.         super("Customer");   
  7.         this.food = food;   
  8.     }   
  9.   
  10.     public void run() {   
  11.         this.consume();   
  12.     }   
  13.        
  14.     public void startConsume() {   
  15.         Thread thread = new Thread(this);   
  16.         thread.start();   
  17.     }   
  18.   
  19.     private void consume() {   
  20.         synchronized(food) {   
  21.             while(true) {   
  22.                 if(food.getFoodNum() <= 0) {   
  23.                     try {   
  24.                         food.wait();   
  25.                     } catch (InterruptedException e) {   
  26.                         // Do nothing   
  27.                     }   
  28.                 } else {   
  29.                     break;   
  30.                 }   
  31.             }   
  32.             int num = this.food.getFoodNum();   
  33.             num--;   
  34.             this.food.setFoodNum(num);   
  35.             System.out.println(this.getName() + " " + "consume food " + num);   
  36.             food.notify();   
  37.         }   
  38.     }   
  39. }  
public class CustomerThread extends Customer implements Runnable {

	private Food food = null;

	public CustomerThread(Food food) {
		super("Customer");
		this.food = food;
	}

	public void run() {
		this.consume();
	}
	
	public void startConsume() {
		Thread thread = new Thread(this);
		thread.start();
	}

	private void consume() {
		synchronized(food) {
			while(true) {
				if(food.getFoodNum() <= 0) {
					try {
						food.wait();
					} catch (InterruptedException e) {
						// Do nothing
					}
				} else {
					break;
				}
			}
			int num = this.food.getFoodNum();
			num--;
			this.food.setFoodNum(num);
			System.out.println(this.getName() + " " + "consume food " + num);
			food.notify();
		}
	}
}


ProductorThread类：
Java代码 复制代码  收藏代码
  1. public class ProductorThread extends Productor implements Runnable {   
  2.   
  3.     private Food food = null;   
  4.        
  5.     public ProductorThread(Food food) {   
  6.         super("Productor");   
  7.         this.food = food;   
  8.     }   
  9.   
  10.     public void run() {   
  11.         this.increase();   
  12.     }   
  13.        
  14.     public void startIncrease() {   
  15.         Thread thread = new Thread(this);   
  16.         thread.start();   
  17.     }   
  18.   
  19.     private void increase() {   
  20.         synchronized(food) {   
  21.             while(true) {   
  22.                 if(food.getFoodNum() == Food.MAX_NUM) {   
  23.                     try {   
  24.                         food.wait();   
  25.                     } catch (InterruptedException e) {   
  26.                         // Do nothing   
  27.                     }   
  28.                 } else {   
  29.                     break;   
  30.                 }   
  31.             }   
  32.             int num = this.food.getFoodNum();   
  33.             num++;   
  34.             this.food.setFoodNum(num);   
  35.             System.out.println(this.getName() + " " + "increase food " + num);   
  36.             food.notify();   
  37.         }   
  38.     }   
  39. }  
public class ProductorThread extends Productor implements Runnable {

	private Food food = null;
	
	public ProductorThread(Food food) {
		super("Productor");
		this.food = food;
	}

	public void run() {
		this.increase();
	}
	
	public void startIncrease() {
		Thread thread = new Thread(this);
		thread.start();
	}

	private void increase() {
		synchronized(food) {
			while(true) {
				if(food.getFoodNum() == Food.MAX_NUM) {
					try {
						food.wait();
					} catch (InterruptedException e) {
						// Do nothing
					}
				} else {
					break;
				}
			}
			int num = this.food.getFoodNum();
			num++;
			this.food.setFoodNum(num);
			System.out.println(this.getName() + " " + "increase food " + num);
			food.notify();
		}
	}
}


Food类：
Java代码 复制代码  收藏代码
  1. public class Food {   
  2.   
  3.     public static final int MAX_NUM = 10;   
  4.   
  5.     private int foodNum = 0;   
  6.   
  7.     public Food(int foodNum) {   
  8.         this.foodNum = foodNum;   
  9.     }   
  10.   
  11.     public void setFoodNum(int foodNum) {   
  12.         this.foodNum = foodNum;   
  13.     }   
  14.   
  15.     public int getFoodNum() {   
  16.         return this.foodNum;   
  17.     }   
  18. }  
public class Food {

	public static final int MAX_NUM = 10;

	private int foodNum = 0;

	public Food(int foodNum) {
		this.foodNum = foodNum;
	}

	public void setFoodNum(int foodNum) {
		this.foodNum = foodNum;
	}

	public int getFoodNum() {
		return this.foodNum;
	}
}


MainTest类：
Java代码 复制代码  收藏代码
  1. public class MainTest {   
  2.     public static void main(String[] args) {   
  3.         Food food = new Food(0);   
  4.            
  5.         CustomerThread customer = new CustomerThread(food);   
  6.         customer.startConsume();   
  7.         CustomerThread customer1 = new CustomerThread(food);   
  8.         customer1.startConsume();   
  9.         CustomerThread customer2 = new CustomerThread(food);   
  10.         customer2.startConsume();   
  11.         CustomerThread customer3 = new CustomerThread(food);   
  12.         customer3.startConsume();   
  13.         CustomerThread customer4 = new CustomerThread(food);   
  14.         customer4.startConsume();   
  15.         CustomerThread customer5 = new CustomerThread(food);   
  16.         customer5.startConsume();   
  17.            
  18.         ProductorThread productor = new ProductorThread(food);   
  19.         productor.startIncrease();   
  20.         ProductorThread productor1 = new ProductorThread(food);   
  21.         productor1.startIncrease();   
  22.         ProductorThread productor2 = new ProductorThread(food);   
  23.         productor2.startIncrease();   
  24.         ProductorThread productor3 = new ProductorThread(food);   
  25.         productor3.startIncrease();   
  26.         ProductorThread productor4 = new ProductorThread(food);   
  27.         productor4.startIncrease();   
  28.         ProductorThread productor5 = new ProductorThread(food);   
  29.         productor5.startIncrease();   
  30.   
  31.   
  32.   
  33.     }   
  34. }  
public class MainTest {
	public static void main(String[] args) {
		Food food = new Food(0);
		
		CustomerThread customer = new CustomerThread(food);
		customer.startConsume();
		CustomerThread customer1 = new CustomerThread(food);
		customer1.startConsume();
		CustomerThread customer2 = new CustomerThread(food);
		customer2.startConsume();
		CustomerThread customer3 = new CustomerThread(food);
		customer3.startConsume();
		CustomerThread customer4 = new CustomerThread(food);
		customer4.startConsume();
		CustomerThread customer5 = new CustomerThread(food);
		customer5.startConsume();
		
		ProductorThread productor = new ProductorThread(food);
		productor.startIncrease();
		ProductorThread productor1 = new ProductorThread(food);
		productor1.startIncrease();
		ProductorThread productor2 = new ProductorThread(food);
		productor2.startIncrease();
		ProductorThread productor3 = new ProductorThread(food);
		productor3.startIncrease();
		ProductorThread productor4 = new ProductorThread(food);
		productor4.startIncrease();
		ProductorThread productor5 = new ProductorThread(food);
		productor5.startIncrease();



	}
}


终于写完了，累死我了~~~

 

caolaosanahnu
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java 线程的简单例子
zhanglp的专栏
10-24 728
Java线程：概念与原理 一、操作系统中线程和进程的概念 现在的操作系统是多任务操作系统。多线程是实现多任务的一种方式. 进程是指一个内存中运行的应用程序，每个进程都有自己独立的一块内存空间，一个进程中可以启动多个线程。比如在Windows系统中，一个运行的exe就是一个进程。 线程是指进程中的一个执行流程，一个进程中可以运行多个线程。比如java.exe进程中可以运行很多
java多线程（四）：Runnable和Thread的简单使用
weixin_42046829的博客
09-09 281
public class MyRunnable implements Runnable{ private String name; public MyRunnable(String name) { this.name = name; } @Override public void run() { for (int i = 1; i < 11; i++){ System.out.println(nam.
三、Thread 类和Runnable 接口详解
shiyu_951的博客
08-09 1496
三、Thread 类和Runnable 接口详解
java多线程－－－Thread和Runnable简单实例
Venus 的博客
11-03 2115
线程简单的实例　Thread/ Runnable
java多线程简单小例子2——实现Runnable接口
路漫漫其修远兮 吾将上下而求索
03-25 4095
/** * 实现Runnable接口的类 * * @author */ public class DoSomething implements Runnable { private String name; public DoSomething(String name) { this.name = name; } public void run(
Java Runnable多线程理解(简单)
_Adler.
10-06 202
public class thread {     public static void main (String[] args) {         Th1 t1 = new Th1(1);         new Thread(t1).start(); //方法1         Th1 t2 = new Th1(2);         t2.run();         t2.run(); ...
单线程实例区别Thread和Runnable方法
杨鑫newlife的专栏
04-15 1614
学习线程的时候肯定会接触到一个类Thread和一个接口Runnable 这两个方法都可以实现线程的使用，那么接下来我用两个例子来给大家讲解一下这两个分别怎么用 //=======================================================================// 实现Runnable //=======================
JAVA多线程Thread和Runnable的实现
09-05
总结来说，Java中实现多线程可以通过继承`Thread`或实现`Runnable`接口。继承`Thread`适合那些需要扩展`Thread`类功能的情况，而实现`Runnable`接口则更灵活，适用于不希望受到单继承限制的场合。无论哪种方式，都...
浅析Java中Runnable和Thread的区别
08-31
无论是继承`Thread`还是实现`Runnable`，都需要提供一个`run()`方法，因为这是Java线程执行的核心。在`run()`方法中定义的代码会被线程调度器按需调用，给人一种多线程同时运行的错觉，实际上是CPU在不同线程间快速...
Java多线程实现Runnable方式
08-27
在Java中，实现多线程有两种主要方式：继承Thread类和实现Runnable接口。本篇主要讨论实现Runnable接口的方式。 首先，我们要了解实现Runnable接口的基本步骤： 1. 定义一个类实现Runnable接口。这一步是为了创建...
java线程之使用Runnable接口创建线程的方法
09-05
Java提供了两种主要的方式来创建线程：继承Thread类和实现Runnable接口。本文将详细讲解使用Runnable接口创建线程的方法。 首先，为什么我们要选择实现Runnable接口而不是直接继承Thread类呢？这是因为Java不支持...
java线程之用Thread类创建线程的方法
09-05
在Java编程语言中，创建线程主要有两种方式：使用`Thread`类以及实现`Runnable`接口。本篇文章将深入探讨如何使用`Thread`类来创建和管理线程。 首先，让我们了解一下`Thread`类的基本构造方法。`Thread`类提供了多...
EduCoder-JavaJava高级特性 - 多线程基础（1）实现代码以及相关知识点
小康小白的博客
05-20 5362
我是小康小白，一个平平无奇的Java小白。热爱有趣的文字，生活和远方。 第1关：创建线程 任务描述 本关任务：创建一个Java线程执行特定任务。 相关知识 不知道你有没有发现，截止目前，我们编写的代码都是在main()函数中依照编写代码的顺序从上到下依次运行的。 但是我们平常使用的软件基本都是可以多个任务同时执行的，这其中的运行机制是什么呢？这一小节我们就来探讨。 本小节我们来学习Java中程序是如何同时执行多个任务的。 什么是线程、什么是进程 在Java中要同时执行（如果是单核，准确的说是交替执行
Java 线程简单示例
啸铁
09-25 381
Java 线程可以通过 extends Thread 类来实现，也可以 implements Runnable 接口来实现。 示例 下面的例子分别给出了通过 extends Thread 和 implements Runnable 来实现线程的例子。可以看出，无论哪种方法，都要实现 public static void run() 方法，调用时先 new Runner() 或 new ExtendsThread，然后将 new 出的对象传入Thread(), 构造一个 Thread 对象, 调用 Threa
多线程例子 Runnable 例子。
wulong710的专栏
09-01 1885
开始学习JAVA 准备搞android 多线程例子 Runnable 例子： import java.applet.Applet; /** * Created by IntelliJ IDEA. * User: wulong * Date: 11-9-8 * T
两种线程：Runable与Thread区别详解
启舰
07-17 5369
前言：由于毕业
Thread and Runnable
Gab的专栏
12-15 463
<br />想要简单的启动一个线程直接实现Runnable的接口就可以了。在runnable里面实现run()函数。<br />需要复杂一点的线程管理等等的功能最好是用thread。可以将runnable的实例给thread的构造函数，来运行这个runnable规定的任务。当thread调用start函数时候，就会调用到runnable的run函数。<br /> <br />转载自：http://mgc.name/article.asp?id=823<br />Thread的run()和start()方法的
JAVA 几种多线程的简单实例 Thread Runnable
大事龙
12-29 4559
实例1:class Hello extends Thread{private String name;public Hello(){}public Hello(String name){this.name = name;}public void run(){for(int i=0
JAVA进阶补充
最新发布
2301_80150315的博客
08-15 1011
概念：把已经有的方法拿过来用，当作函数式接口中抽象方法的方法体条件：引用处必须是函数式接口被引用的方法需要已经存在被引用方法的形参和返回值需要跟抽象方法的形参和返回值保持一致被引用方法的功能需要满足当前需求：方法引用符意义：就是为让控制台的报错信息更加的见名知意自定义异常的步骤：定义异常类写继承关系空参构造带参构造​file对象就表示一个路径，可以是文件的路径、也可以是文件夹的路径；这个路径可以是存在的，也允许是不存在的构造方法描述根据文件路径创建对象。
Java创建线程：Thread、Runnable、Callable详解
"本文介绍了Java中创建线程的三种方式：继承Thread类、实现Runnable接口以及使用Callable接口。首先，详细讲述了通过继承Thread类来创建线程的步骤和注意事项，包括如何重写run()方法来定义线程行为，以及如何通过...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值