线程的创建主要有四种方式，
一种是直接继承Thread实现，
另一种是引用接口Runable。
也可以运用内部类实现接口的创建。但是用这种方法创建的线程只能用一次。以下就是线程的四种创建方式的相关代码：
public class TestThread {
public static void main(String[] args) {
MyThread1 mt = new MyThread1();
MyThread2 mt2 = new MyThread2();
mt.start();
new Thread(mt2).start();
new Thread() {//内部类实现
public void run() {
for (int i = 0; i < 100; i++) {
System.out.println("++++线程3++++++" + i);
}
}
}.start();
new Thread(new Runnable() {
@Override
public void run() {
for (int i = 0; i < 100; i++) {
System.out.println("******线程4****" + i);
}
}
}).start();
for (int i = 0; i < 100; i++) {
System.out.println("******主线程****" + i);
}
}
}
/**
*
* 四种方法实现线程的创建，两种运用的是内部类 一种是实现接口，一种是继承线程
*
*/
class MyThread1 extends Thread {
@Override
public void run() {
for (int i = 0; i < 100; i++) {
System.out.println("++++线程一++++++" + i);
}
}
}
class MyThread2 implements Runnable {
@Override
public void run() {
for (int i = 0; i < 100; i++) {
System.out.println("-----线程二-------" + i);
}
}
}
当想让线程暂时暂停，进入休眠状态，可以用Sleep实现，该方法是静态方法，可以直接被Thread引用。可以在方法中设置休眠的时间。下面通过一个例子来说明Sleep的用法
import java.io.IOException;
import java.nio.CharBuffer;
public class TestSleep {
public static void main(String[] args) {
Runner r = new Runner();
Thread t1 = new Thread(r);
Thread t2 = new Thread(r);
t1.start();
t2.start();
}
}
class Runner implements Runnable {
@Override
public void run() {
for (int i = 0; i < 200; i++) {
if (i % 10 == 0 && i != 0) {
try {
Thread.sleep(1000); //Sleep的用法
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println("——————————线程————————————" + i);
}
}
}
当想让一个线程先执行完再去执行另一个线程时，可以用Join方法将当前线程先执行完。下面通过一个例子来说明Join的用法。
public class TestJoin {
public static void main(String[] args) {
MyThread2 t1 = new MyThread2("zhangcun");
t1.start();
try {
t1.join();//先执行调用join方法的线程对象的run方法，完成后才调用这条语句所在的线程
} catch (InterruptedException e) {
e.printStackTrace();
}
for (int i = 1; i <= 10; i++) {
System.out.println("------i am main thread");
}
}
}
class MyThread2 extends Thread {
MyThread2(String s) {
super(s);
}
public void run() {
for (int i = 1; i <= 10; i++) {
System.out.println("I am " + getName());
try {
sleep(1000);
} catch (InterruptedException e) {
System.out.println("又被打爆了！");
return;
}
}
}
}
当需要一个线程让出当前执行状态即CPU，给其他线程执行的机会，就需要使用Yield方法，使当前线程暂时阻塞，让程序去执行其他的线程。还是通过一个例子来说明。
public class TestYield {
public static void main(String[] args) {
MyYield my1 = new MyYield();
MyYield2 my2 = new MyYield2();
my1.start();
my2.start();
}
}
class MyYield extends Thread {
@Override
public void run() {
for (int i = 0; i < 100; i++) {
System.out.println("数字为：" + i);
if (i % 10 == 0 && i != 0) {
yield();
}
}
}
}
class MyYield2 extends Thread {
@Override
public void run() {
for (int i = 0; i < 100; i++) {
System.out.println("线程二数字为：" + i);
if (i % 10 == 0 && i != 0) {
yield();
}
}
}
}
判断当前线程是否还在执行可以使用Thread.currentThread().isAlive()实现。
如果想让某一个线程的优先级优先，可以通过setPriority来设置线程的优先级。当然也会有一个getPriority来获取优先级MinPriority=1，MaxPriority=10，NomPriority=5。下面通过一个例子来说明setPriority的用法。
public class TestPriority {
public static void main(String[] args) {
T1 t = new T1();
T2 tt = new T2();
tt.setPriority(Thread.NORM_PRIORITY + 4);//设置线程的优先级来改变线程的优先级
t.start();
tt.start();
}
}
class T1 extends Thread {
@Override
public void run() {
for (int i = 0; i < 100; i++) {
System.out.println("线程T1" + i);
}
}
}
class T2 extends Thread {
@Override
public void run() {
for (int i = 0; i < 100; i++) {
System.out.println("--------线程T2" + i);
}
}
}
如果想实现当一个线程在占用一个资源时，不让别的线程来抢占资源，可以使用synchronized来修饰方法或者语句块，这样别的线程就不会进入synchronized修饰的方法或者方法块。
wait()和sleep()的区别：
<1>wait（）时别的线程可以访问锁定对象。
<2>调用该方法时必须锁定该对象。
<3>sleep（）时别的线程不可以访问锁定对象。
如果两个线程互相占用对方资源，那么线程将会进入死锁状态，在实现线程时，应该尽量避免死锁情况。下面就是一个典型的死锁例子，在编程时，我们应该要避免死锁的发生。
死锁例子：
public class TestDeadLock implements Runnable {
public int flag = 1;
static Object o1 = new Object(), o2 = new Object();
@Override
public void run() {
System.out.println("flag=" + flag);
if (flag == 1) {
synchronized (o1) {
try {
Thread.sleep(500);
} catch (Exception e) {
e.printStackTrace();
}
synchronized (o2) {
System.out.println("1");
}
}
}
if (flag == 0) {
synchronized (o2) {
try {
Thread.sleep(500);
} catch (Exception e) {
e.printStackTrace();
}
synchronized (o1) {
System.out.println("0");
}
}
}
}
public static void main(String[] args) {
TestDeadLock td1 = new TestDeadLock();
TestDeadLock td2 = new TestDeadLock();
td1.flag = 1;
td2.flag = 0;
Thread t1 = new Thread(td1);
Thread t2 = new Thread(td2);
t1.start();
t2.start();
}
}
分享到：
相关推荐
本资源包含六个完整的多线程实例，涵盖了从基础使用到高级特性的全面实践，例如线程的创建、同步与互斥。 1. **线程的创建**：在C#.NET中，可以使用`System.Threading.Thread`类来创建新的线程。实例可能演示了如何...
在Java编程中，多线程并发是...总之，Java的多线程并发实例可以帮助我们更好地理解和实践线程控制、同步机制以及经典的设计模式，提升我们的编程能力。通过不断学习和实践，我们可以编写出高效、安全的多线程并发程序。
本文将探讨如何在Windows环境下通过简单的命令行工具来监控JVM实例的数量，以及如何进行线程测试，特别是在单例模式下的JVM实例验证。 首先，了解如何监控JVM实例数量。在Windows操作系统中，我们可以使用`jps`命令...
这些实例涵盖了多线程的基础和进阶应用，从简单的线程创建到复杂的同步机制，有助于理解和掌握C#.NET中的多线程编程。在实际项目中，根据需求选择合适的方法进行线程管理，可以有效提高程序性能并防止数据不一致性。
线程安全的单例模式在多线程环境下尤其重要，因为不正确的实现可能导致多个线程创建多个实例，这违反了单例模式的基本原则。C++11引入了新的特性，如std::mutex和std::call_once，使得实现线程安全的单例模式变得...
在懒汉式基础上利用synchronize关键字和volatile关键字确保第一次创建时没有线程间竞争而产生多个实例，仅第一次创建时同步，性能相对较高 登记式。作为创建类的全局属性存在，创建类被装载时创建 枚举。java中枚举...
标题"根据不同的模式创建单实例应用程序(3kb)"暗示我们将探讨几种实现单例模式的方法，可能是通过C++语言来完成，文件`SingleInstance.cpp`和`SingleInstance.h`可能包含了这些实现的源代码。 1. **经典单例模式**...
本文将深入探讨工作线程的使用实例，以及为什么调用类的函数时应发送消息而非直接调用。 一、工作线程基础 1. 定义：工作线程，也称为后台线程或非UI线程，是在应用程序运行过程中，除了主线程之外创建的额外线程...
2. **线程池的优势**：减少线程创建和销毁的开销，更好地控制并发量，防止资源耗尽。 **线程安全** 1. **线程安全**：如果一个方法在多线程环境下能正确运行，我们就说它是线程安全的。常见的线程安全问题包括数据...
总之，"socket多线程例程非阻塞模式"是一个实用的编程实例，涵盖了网络通信、多线程以及异步处理的关键技术，对于学习和理解这些概念非常有价值。通过对源代码的分析和实践，开发者能够提升自己的网络编程技能，为...
线程安全的Singleton模式对于多线程环境尤为重要，因为它可以防止多个线程同时创建多个实例。本文将详细介绍如何在Java中创建线程安全的Singleton，包括几种常见的实现方式和最佳实践。 在Java中创建线程安全的...
1. **线程创建**：使用`System.Threading.Thread`类创建新线程，如`new Thread(new ThreadStart(MyBackgroundMethod))`，其中`MyBackgroundMethod`是后台任务的方法。 2. **线程启动**：通过调用`Thread.Start()`...
单例模式（Singleton Pattern）是软件开发中最常用的创建型设计模式之一，它的主要目标是确保一个类只有一个实例，并提供一个全局访问点。单例模式在很多场景下都非常有用，例如系统配置管理、日志记录等场合，这些...
本资源描述了C++11 中多线程的创建，C++11中std命名空间中将boost库中的Thread加入，boost多线程从准标准变为标准，其中还介绍了C++ 多线程下的单例模式的使用，本文档为txt文档
总之，这份Java多线程设计模式源代码涵盖了从基本的线程创建到复杂的线程同步、通信和线程池管理，以及各种线程安全的类和设计模式的实战应用。通过学习和分析这些源码，开发者能够更好地理解和掌握Java多线程编程，...
下面我们将详细讲解这四种单例模式并提供相应的实例。 1. **GCD（Grand Central Dispatch）单例** GCD是Apple提供的多线程解决方案，可以用来创建单例。它的优点在于线程安全，避免了同步锁的使用。 ```swift ...
- **动态创建**：可以依据程序运行时的需求动态地创建线程实例，执行不同的任务。 3. **线程的创建方式**：在Java中，可以通过继承`Thread`类或实现`Runnable`接口来创建线程。Python中，可以使用`threading`库中...
工厂模式是一种创建型设计模式，它提供一个接口来创建对象，但让子类决定实例化哪一个类。工厂方法让类的实例化推迟到子类中进行。在Java中，我们可以创建一个抽象工厂接口，定义产品对象的创建方法，然后由具体...
以下是对这四种单例模式的详细解释和实例分析。 1. **GCD（Grand Central Dispatch）单例** 使用GCD创建单例，利用`dispatch_once`函数保证线程安全。这种方式简单且高效，是推荐的Swift早期版本中的单例实现方式...
本实例主要探讨的是使用C++实现基于Socket的多线程通信，具体涉及了VC++（Visual C++）环境下的开发，以及C/S（Client/Server）架构的双向通信模式。下面我们将详细讲解相关知识点。 首先，Socket是网络通信的基本...