Java学习记录七

最新推荐文章于 2021-11-21 20:01:33 发布

毋十三

最新推荐文章于 2021-11-21 20:01:33 发布

阅读量127

点赞数

本文链接：https://blog.csdn.net/qq_34117624/article/details/83316337

版权

定义一个线程

public class MyThread extends Thread {
	@Override
	public void run() {
		for (int x = 0; x < 200; x++) {
			System.out.println(x);
		}
	}
}

启动一个线程

        // 面试题：run()和start()的区别?
       // run():仅仅是封装被线程执行的代码，直接调用是普通方法
       // start():首先启动了线程，然后再由jvm去调用该线程的run()方法。

	public static void main(String[] args) {
		// 创建两个线程对象
		MyThread my1 = new MyThread();
		my1.start();
	}

常用方法

* public final String getName():获取线程的名称。

* public final void setName(String name):设置线程的名称

        * 针对不是Thread类的子类中如何获取线程对象名称呢?
            * public static Thread currentThread():返回当前正在执行的线程对象
            * Thread.currentThread().getName()

举个栗子：获得main函数线程名称

	public static void main(String[] args) {
		//public static Thread currentThread():返回当前正在执行的线程对象
		System.out.println(Thread.currentThread().getName());
	}

* public final void setDaemon(boolean on):将该线程标记为守护线程或用户线程。
* 当正在运行的线程都是守护线程时，Java 虚拟机退出。该方法必须在启动线程前调用。

* public final void join():等待该线程跑完终止。

           * 如何获取线程对象的优先级?
              *        public final int getPriority():返回线程对象的优先级
              * 如何设置线程对象的优先级呢?
              *        public final void setPriority(int newPriority)：更改线程的优先级。
              *
              * 注意：
              *        线程默认优先级是5。
              *        线程优先级的范围是：1-10。
              *        线程优先级高仅仅表示线程获取的 CPU时间片的几率高，次数多的时候看到比较明显。

* 线程休眠
* public static void sleep(long millis)

* 线程的骨折

* public final void stop():让线程停止，过时了，但是还可以使用。
* public void interrupt():中断线程。把线程的状态终止，并抛出一个InterruptedException。

*线程的分配

* public static void yield():暂停当前正在执行的线程对象，并执行其他线程。如果其他线程也暂停了，就执行刚开始暂停的线程，所以某种情况下回很和谐。
* 让多个线程的执行更和谐，但是不能靠它保证一人一次。

创建线程的第二种方式

public class MyRunnable implements Runnable {
	@Override
	public void run() {
		for (int x = 0; x < 100; x++) {
			// 由于实现接口的方式就不能直接使用Thread类的方法了,但是可以间接的使用
			System.out.println(Thread.currentThread().getName() + ":" + x);
		}
	}
}

跑起来

	public static void main(String[] args) {
		// 创建MyRunnable类的对象
		MyRunnable my = new MyRunnable();
		Thread t1 = new Thread(my, "林青霞");
		Thread t2 = new Thread(my, "刘意");
		t1.start();
		t2.start();
	}

第二种创建线程的方式更加体现数据共享的概念，只创建了一个线程对象，可以实现某些功能比如：买票。

买票问题的解决方法

个人向:实现接口创建线程，数据共享，所以obj成员变量也是同一个。相当于三个人进同一个屋子，门上了把锁，所以保证了，tickets的值是更新后的。

public class ThreadJoin extends Thread{
	private int tickets=100;
	private Object obj=new Object();
	@Override
	public void run() {
		while (true) {
			synchronized(obj){
				if (tickets > 0) {
					try {
						Thread.sleep(100); 
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
					System.out.println(Thread.currentThread().getName() + "正在出售第"
							+ (tickets--) + "张票");
				}
			}
		}
	}
}

任何的东西有好必有坏。

* 同步的好处
* 同步的出现解决了多线程的安全问题。
* 同步的弊端
* 当线程相当多时，因为每个线程都会去判断同步上的锁，这是很耗费资源的，无形中会降低程序的运行效率。

除了给成员变量上锁外，还有其他方法

             * A:同步代码块的锁对象是谁呢?
             *        任意对象。
             *
             * B:同步方法的格式及锁对象问题?
             *        把同步关键字加在方法上。
             *
             *        同步方法是谁呢?
             *            this
             *
             * C:静态方法及锁对象问题?
             *        静态方法的锁对象是谁呢?
             *            类的字节码文件对象。(反射会讲)

线程安全

		StringBuffer sb = new StringBuffer();
		Vector<String> v = new Vector<String>();
		Hashtable<String, String> h = new Hashtable<String, String>();

		// Vector是线程安全的时候才去考虑使用的，但是我还说过即使要安全，我也不用你
		// 那么到底用谁呢?
		// public static <T> List<T> synchronizedList(List<T> list)
		List<String> list1 = new ArrayList<String>();// 线程不安全
		List<String> list2 = Collections.synchronizedList(new ArrayList<String>()); // 线程安全

线程的生命周期

* Lock：
* void lock()：获取锁。
* void unlock():释放锁。
* ReentrantLock是Lock的实现类.

public class SellTicket implements Runnable {

	// 定义票
	private int tickets = 100;

	// 定义锁对象
	private Lock lock = new ReentrantLock();

	@Override
	public void run() {
		while (true) {
			try {
				// 加锁
				lock.lock();
				if (tickets > 0) {
					try {
						Thread.sleep(100);
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
					System.out.println(Thread.currentThread().getName()
							+ "正在出售第" + (tickets--) + "张票");
				}
			} finally {
				// 释放锁
				lock.unlock();
			}
		}
	}

}

* 同步的弊端：
*        A:效率低
*        B:容易产生死锁
*
* 死锁：
*        两个或两个以上的线程在争夺资源的过程中，发生的一种相互等待的现象。

public class MyLock {
	// 创建两把锁对象
	public static final Object objA = new Object();
	public static final Object objB = new Object();
}
-------------------------------------------------------
public class DieLock extends Thread {

	private boolean flag;

	public DieLock(boolean flag) {
		this.flag = flag;
	}

	@Override
	public void run() {
		if (flag) {
			synchronized (MyLock.objA) {
				System.out.println("if objA");
				synchronized (MyLock.objB) {
					System.out.println("if objB");
				}
			}
		} else {
			synchronized (MyLock.objB) {
				System.out.println("else objB");
				synchronized (MyLock.objA) {
					System.out.println("else objA");
				}
			}
		}
	}
}
--------------------------------------------------------------------
	public static void main(String[] args) {
		DieLock dl1 = new DieLock(true);
		DieLock dl2 = new DieLock(false);

		dl1.start();
		dl2.start();
	}

生产者消费者模型

*        Object类中提供了三个方法：
*            wait():等待
*            notify():唤醒单个线程
*            notifyAll():唤醒所有线程
*        为什么这些方法不定义在Thread类中呢?
*            这些方法的调用必须通过锁对象调用，而我们刚才使用的锁对象是任意锁对象。
*            所以，这些方法必须定义在Object类中。

public class Student {
	String name;
	int age;
	boolean flag; // 默认情况是没有数据，如果是true，说明有数据
}
--------------------------------------------------------
public class SetThread implements Runnable {

	private Student s;
	private int x = 0;

	public SetThread(Student s) {
		this.s = s;
	}

	@Override
	public void run() {
		while (true) {
			synchronized (s) {
				//判断有没有
				if(s.flag){
					try {
						s.wait(); //t1等着，释放锁
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
				}
				
				if (x % 2 == 0) {
					s.name = "林青霞";
					s.age = 27;
				} else {
					s.name = "李二狗";
					s.age = 30;
				}
				x++; //x=1
				
				//修改标记
				s.flag = true;
				//唤醒线程
				s.notify(); //唤醒t2,唤醒并不表示你立马可以执行，必须还得抢CPU的执行权。
			}
			//t1有，或者t2有
		}
	}
}
------------------------------------------------------------------------------
public class GetThread implements Runnable {
	private Student s;

	public GetThread(Student s) {
		this.s = s;
	}

	@Override
	public void run() {
		while (true) {
			synchronized (s) {
				if(!s.flag){
					try {
						s.wait(); //t2就等待了。立即释放锁。将来醒过来的时候，是从这里醒过来的时候
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
				}
				
				System.out.println(s.name + "---" + s.age);
				//林青霞---27
				//刘意---30
				
				//修改标记
				s.flag = false;
				//唤醒线程
				s.notify(); //唤醒t1
			}
		}
	}
}
-----------------------------------------------------------------------
	public static void main(String[] args) {
		//创建资源
		Student s = new Student();
		
		//设置和获取的类
		SetThread st = new SetThread(s);
		GetThread gt = new GetThread(s);

		//线程类
		Thread t1 = new Thread(st);
		Thread t2 = new Thread(gt);

		//启动线程
		t1.start();
		t2.start();
	}

* 线程组：把多个线程组合到一起。
* 它可以对一批线程进行分类管理，Java允许程序直接对线程组进行控制。

// 线程类里面的方法：public final ThreadGroup getThreadGroup() 获得当前线程所属的线程组

// 线程组里面的方法：public final String getName()

// 线程默认情况下属于main线程组，默任情况下，所有的线程都属于同一个组

public class MyRunnable implements Runnable {

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

}
-----------------------------------------------------------------
	private static void method2() {
		// ThreadGroup(String name)
		ThreadGroup tg = new ThreadGroup("这是一个新的组");

		MyRunnable my = new MyRunnable();
		// Thread(ThreadGroup group, Runnable target, S

最低0.47元/天解锁文章

毋十三

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java学习记录七

定义一个线程public class MyThread extends Thread { @Override public void run() { for (int x = 0; x &lt; 200; x++) { System.out.println(x); } }}启动一个线程 // 面试题：run()和start()的区别? ...
复制链接

扫一扫