多线程spawn 调用 避免爆gpu 显存 多线程的调用

 1.线程和进程:
进程:正在运行的程序。
线程:就是进程的一条执行路径，或者叫执行单元。

2.多线程:
有用多个执行线路的程序。

3.多线程实现方式1:继承Thread类
步骤:
1.创建一个类，该类继承Thread
2.重写run方法，把你想让这个线程执行的代码放进run方法中。
3.创建Thread的子类的对象。
4.调用start方法，启动线程。
案例:

public class MyThread extends Thread {
 @Override
 public void run() {
 //想让这个线程执行的代码
 }
 }

//3.创建Thread的子类的对象。
MyThread mt = new MyThread();
//4.调用start方法，启动线程。
mt.start(); 

public class MyThread extends Thread {
	@Override
	public void run() {
		for (int i = 0; i < 100; i++) {
			System.out.println(getName() + ":" + i);
		}
	}
}




/*
 * 多线程的实现方式：
 * 		方式1：一种方法是将类声明为 Thread 的子类。该子类应重写 Thread 类的 run 方法。接下来可以分配并启动该子类的实例
 * 
 * Thread
 * 		String getName()      返回该线程的名称。 
 * 		void   setName(String name) 改变线程名称，使之与参数 name 相同。
 * 
 * 
 * CPU执行程序的随机性
 */
public class ThreadDemo2 {
	public static void main(String[] args) {
		//创建线程实例
		MyThread mt = new MyThread();
		//修改线程名字
		mt.setName("张三");
		
		//启动线程
		mt.start();
		
		//创建线程实例
		MyThread mt2 = new MyThread();
		mt2.setName("老王");
		
		//启动线程
		mt2.start();
	}
}

4.多线程实现方式2:实现Runnable接口
步骤:
1.创建一个类，该类实现实现Runnable接口
2.重写run方法，把你想让这个线程执行的代码放进run方法中。
3.创建一个Runnable子类的对象
4.创建Thread类的对象，构造方法的参数是“Runnable子类的对象”
5.调用Thread的start方法，启动线程

案例:

public class MyRunnable implements Runnable {
 @Override
 public void run() {
 //想让这个线程执行的代码
 }
 }

//3.创建一个Runnable子类的对象
MyRunnable mr = new MyRunnable();
//4.创建Thread类的对象，构造方法的参数是“Runnable子类的对象”
Thread t = new Thread(mr);
//5.调用Thread的start方法，启动线程
t.start(); 

public class MyThread2 implements Runnable {
	int num;
	
	public MyThread2(int num) {
		this.num = num;
	}
	
	@Override
	public void run() {
		for (int i = 0; i < 100; i++) {
			//Thread t = Thread.currentThread();
			//System.out.println(t.getName() + ":" + i);
			
			//链式编程
//Thread.currentThread().getName() 获取当前线程的名称，谁调用它，显示谁的名字
//如果不new Thread，直接调用这个类的run方法，那么打印的是主函数的名字
			System.out.println(Thread.currentThread().getName() + ":" + i + num);
		}
	}

}

public class ThreadDemo01 {
/*
 * String getName   返回线程的名称
 * void setName（String  name）  返回线程的名称，使名称和name相同
 * */
	public static void main(String[] args) {
		    
			MyThread2 mt = new MyThread2();
			Thread thread1 = new Thread(mt);
			thread1.setName("小黑");
			thread1.start();
			Thread thread2 = new Thread(mt);
			thread2.setName("小白");
			thread2.start();
			Thread thread3 = new Thread(mt);
			thread3.setName("小绿");
			thread3.start();
		
		
	
	}

}

5.Thread的常用:

static Thread currentThread(); //获取当前线程对象。
 String getName();  //获取线程的名字
 void setName(String name); //设置线程的名字
 static void sleep(long millis);  //让当前线程睡一会。单位是毫秒
 void start();  //启动线程。所谓的启动并不是立即执行，是否执行要看人家CPU。

6.同步代码块:

synchronized(锁对象){
 //需要同步的代码
 }

注意：
1.当加上同步之后，该段代码在一个线程执行时，另外一个线程就不允许执行。
2.锁对象必须被所有线程共享。大家用的必须是同一把锁。
3.锁对象必须是引用数据类型、

/*
 * 问题出现的原因：
 * 		要有多个线程
 * 		要有被多个线程所共享的数据
 * 		多个线程并发的访问共享的数据
 * 
 * 在火车上上厕所
 * 张三来了，一看门是绿的，他就进去了，把门锁上了，门就变红了
 * 李四来了，一看门市红色的，他就只能憋着
 * 张三用完了厕所，把锁打开了，门就变成了绿色
 * 李四一看门变绿了，他就进去了，把门锁上，门就变红了
 * 王五来了，一看们是红色的，他也只能憋着
 * 李四用完测试了，把锁打开了，肚子又不舒服了，扭头回去了，又把门锁上了，
 * 
 * synchronized:同步（锁），可以修饰代码块和方法，被修饰的代码块和方法一旦被某个线程访问，则直接锁住，其他的线程将无法访问
 * 
 * 同步代码块：
 * 			synchronized(锁对象){
 * 
 * 			}
 * 
 * 注意：锁对象需要被所有的线程所共享
 * 
 * 
 * 同步：安全性高，效率低
 * 非同步：效率高，但是安全性低
 * 
 */
public class TicketThread implements Runnable {
	int tickets = 100;//火车票数量
	Object obj = new Object();
	
	@Override
	public void run() {
		//出售火车票
		while(true) {
			synchronized (obj) {

				if(tickets > 0) {
					
					try {
						Thread.sleep(100);
					} catch (InterruptedException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
					
					System.out.println(Thread.currentThread().getName() + ":" +tickets--);
				}
			}
			
		}
	}

}

public class TicktetTest {
	public static void main(String[] args) {
		//创建线程对象
		TicketThread tt = new TicketThread();
		
		Thread t = new Thread(tt);
		t.setName("窗口1");
		Thread t2 = new Thread(tt);
		t2.setName("窗口2");
		Thread t3 = new Thread(tt);
		t3.setName("窗口3");
		
		//启动线程对象
		t.start();
		t2.start();
		t3.start();
	}
}

7.同步方法:
//在方法上加上synchronized。 

访问修饰符 synchronized 返回值类型 方法名(){} 

格式:
  修饰符 synchronized 返回值 方法名(){

}

/*
 * 同步方法:使用关键字synchronized修饰的方法，一旦被一个线程访问，则整个方法全部锁住，其他线程则无法访问
 * 
 * synchronized
 * 注意：
 * 		非静态同步方法的锁对象是this
 * 		静态的同步方法的锁对象是当前类的字节码对象
 */
public class TicketThread implements Runnable {
	static int tickets = 100;// 火车票数量
	Object obj = new Object();

	@Override
	public void run() {
		// 出售火车票
		while (true) {
			/*synchronized (obj) {
				method();
			}*/
			
			//method();
			method2();

		}
	}

	private synchronized void method() {
		if (tickets > 0) {
           
			try {
				Thread.sleep(100);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}

			System.out.println(Thread.currentThread().getName() + ":" + tickets--);
		}
	}
	
	
	private static synchronized void method2() {
	
		if (tickets > 0) {

			try {
				Thread.sleep(100);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}

			System.out.println(Thread.currentThread().getName() + ":" + tickets--);
		}
	}

	

}


//主函数调用

public class TicktetTest {
	public static void main(String[] args) {
		//创建线程对象
		TicketThread tt = new TicketThread();
		
		Thread t = new Thread(tt);
		t.setName("窗口1");
		Thread t2 = new Thread(tt);
		t2.setName("窗口2");
		Thread t3 = new Thread(tt);
		t3.setName("窗口3");

注意:
非静态方法的锁对象是:this 

静态方法的锁对象是: 类的字节码文件。 

摸你卖火车票案例： 

package LianXi01;

public class Test{

	public static void main(String[] args) {
		Ticket ticket = new Ticket();
		Thread t1 = new Thread(ticket, "窗口1");
		Thread t2 = new Thread(ticket, "窗口2");
		Thread t3 = new Thread(ticket, "窗口3");
		t1.start();
		t2.start();
		t3.start();
	}
	
}

class Ticket extends Thread {
	
	int ticket = 100;
	Object obj = new Object();
	
	@Override
	public void run() {
		while (true) {
			synchronized (obj) {
				if(ticket > 0){
					System.out.println(Thread.currentThread().getName() + "@" + ticket--);
				} else {
					System.exit(0);
				}
			}
		}
	}
}

 Thread和Runable的区别： 

             Thread是继承，Runnable是实现:  java只能单一继承，但是可以多实现这就是Runnable的好处