java学习day22

最新推荐文章于 2024-08-03 19:20:31 发布

褪散

最新推荐文章于 2024-08-03 19:20:31 发布

阅读量74

点赞数

分类专栏：笔记

本文链接：https://blog.csdn.net/qq_54406795/article/details/117438164

版权

笔记专栏收录该内容

41 篇文章 0 订阅

订阅专栏

这篇博客介绍了Java中的线程概念，包括主线程、单线程程序的定义，以及如何通过创建Thread子类和实现Runnable接口来创建线程。还强调了实现Runnable接口的好处，并提出了使用同步代码块解决线程安全问题的方法。

摘要由CSDN通过智能技术生成

今天学习了线程
线程：就是进程里面的一个执行单元。
主线程执行main()方法的线程
单线程程序；只有一个线程在执行，从头到尾
java.long.Thread
实现步骤：
1、创建一个Thread类的子类
2、在Thread子类中重写run方法，设置线程任务(干什么)
3、创建Thread子类的对象
4、调用Thread类中的方法start来启动线程，执行run方法

实现runnable 接口创建多线程的好处
1.避免了单线程的局限性
2.增强了程序的扩展性，降低了程序的耦合性
3.创建一个runnable接口的实现类对象

    //RunnableImpl run=new RunnableImpl();
	//4.创建Thread 类对象，构造方法中个传递Runnable 接口实现类对象
	//Thread t=new Thread(run);
	//5.调用Thread 类中的start方法，启动子线程

解决线程安全问题的一种方案：使用同步代码块

格式：
synchronized(锁对象){
可能会出现线程安全的代码(是因为访问了共享的数据)
}
注意：
1、通过代码块中的锁对象，可以使用任意的对象
2、但是必须保证多个线程使用的锁对象是同一个
3、锁对象作用：
把同步代码块锁住，只让一个线程执行

package demo01;
/*
 * 主线程  执行main()方法的线程
 * 
 *单线程程序；只有一个线程在执行，从头到尾 
 * 
 * 
 */
public class Demo01MAainThread {

	public static void main(String[] args) {
		Person p1=new Person("张三");
		p1.run();
		
		
		System.out.println(0/0);
		
		Person p2=new Person("李四");
		p2.run();
		
	}

}

package demo01;
/*
 * java.long.Thread
 * 
 * 实现步骤：
 * 1、创建一个Thread类的子类
 * 2、在Thread子类中重写run方法，设置线程任务(干什么)
 * 3、创建Thread子类的对象
 * 4、调用Thread类中的方法start来启动线程，执行run方法
 * 
 */
public class Demo01MAinThread {
	public static void main(String[] args) {
		//3、创建Thread子类的对象
		MyThread mt=new MyThread();
		
		//4、调用start方法
		mt.start();
		
		for(int i=0;i<20;i++) {
			System.out.println("主线程："+i);
			/*if(i==10)
				System.out.println(0/0);*/
		}
	}
}

package demo01;
//1、创建Thread子类
public class MyThread extends Thread{
	//2、重写run方法
	@Override
	public void run() {
		for(int i=0;i<20;i++) {
			System.out.println("子线程："+i);
		}
	}
}

ackage demo01;

public class Person {
	
	private String name;

	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name=name;
	}
	public Person(String name) {
		this.name = name;
	}
	public Person() {
		
	}
	public void run() {
		for(int i=0;i<20;i++) 
		{
			System.out.println(name+"-->"+i);
		}
	}
	
	
}

package demo02;

import demo01.MyThread;

/*
 * java.long.Thread
 * 
 * 实现步骤：
 * 1、创建一个Thread类的子类
 * 2、在Thread子类中重写run方法，设置线程任务(干什么)
 * 3、创建Thread子类的对象
 * 4、调用Thread类中的方法start来启动线程，执行run方法
 * 
 */
public class Demo01Thread extends Thread {
	public static void main(String[] args) {
		//3、创建Thread子类的对象
		MyThread mt=new MyThread();
		
		//4、调用start方法
		mt.start();//子进程0
		
		new MyThread().start();//子进程1
		
		new MyThread().start();//子进程2
		new MyThread().start();//子进程3
		
		System.out.println("main:"+Thread.currentThread().getName());
		
		}
	}

package demo02;

public class Demo02ThreadSetName {
	public static void main(String[] args) {
		MyThreadName mt=new MyThreadName("张三");
		
		mt.start();
		
		new MyThreadName("李四").start();
	}
}

package demo02;

public class MyThread extends Thread{
	//2.才重写run方法
	@Override
	public void run() {
		
		System.out.println("子"+Thread.currentThread().getName());
	}
}

package demo02;

public class MyThreadName extends Thread {
	
	public MyThreadName() {}
	
	public MyThreadName(String name) {
		
		super(name);//把线程的名字传递给父类，让父类Thread 给子线程取一个名字
	}
	@Override
	public void run() {
		System.out.println("子"+Thread.currentThread().getName());
	}
}

package demo03;

public class Demo03Sleep {
	public static void main(String[] args) {
		for(int i=1;i<60;i++) {
			System.out.println(i);
			
			try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				
				e.printStackTrace();
			}
		}
	}
}

package demo04;
/*
 * 实现runnable 接口创建多线程的好处
 * 1.避免了单线程的局限性
 * 2.增强了程序的扩展性，降低了程序的耦合性
 * 
 * 
 * 
 * 
 */
public class Demo04RunnableImpl {
	public static void main(String[] args) {
		//3.创建一个runnable接口的实现类 对象
        //RunnableImpl run=new RunnableImpl();
		//4.创建Thread 类对象，构造方法中个传递Runnable 接口实现类对象
		//Thread t=new Thread(run);
		//5.调用Thread 类中的start方法，启动子线程
		Thread t=new Thread(new RunnableImpl2());
		t.start();
		
		for(int i=0;i<20;i++) {
			System.out.println(Thread.currentThread().getName()+"-->"+i);
			
		}
	}
}

package demo04;

public class RunnableImpl implements Runnable{
	@Override
	public void run() {
		for(int i=0;i<20;i++) {
			System.out.println(Thread.currentThread().getName());
		}
	}
}

package demo04;

public class RunnableImpl2 implements Runnable{
@Override
public void run() {
	for(int i=0;i<20;i++) {
		System.out.println("Helloworld-->"+i);
	}
}
}

package demo05;

public class Demo01Ticket {
	public static void main(String[] args) {
		RunnableImpl run=new RunnableImpl();
		
		Thread t0=new Thread(run);
		Thread t1=new Thread(run);
		Thread t2=new Thread(run);
		
		t0.start();
		t1.start();
		t2.start();
	}
}

package demo05;
/*
 * 解决线程安全问题的一种方案：使用同步代码块
 * 格式：
 *    synchronized(锁对象){
 *        可能会出现线程安全的代码(是因为访问了共享的数据)
 *    
 *    }
 * 注意：
 * 1、通过代码块中的锁对象，可以使用任意的对象
 * 2、但是必须保证多个线程使用的锁对象是同一个
 * 3、锁对象作用：
 * 把同步代码块锁住，只让一个线程执行
 * 
 * 
 * 
 */
public class RunnableImpl implements Runnable{
private int ticket =100;
Object obj=new Object();
	@Override
	public void run() {
		while(true) {
			
			synchronized(obj) {
			     if(ticket>0) {
				try {
					Thread.sleep(10);
				}catch (InterruptedException e) {
					e.printStackTrace();
				}
				System.out.println(Thread.currentThread().getName()+"-->正在卖第"+ticket+"张票");
				ticket--;
			}
			}
			
		}
		
	}
	

}