多线程之匿名内部类
package Thread; /** * @author FlyFire * @date:2011-10-27 下午07:37:38 * @introduce :以匿名内部类的方式创建线程 * */ public class InternalThread { //程序主函数 public static void main(String args[]){ for(int i=0;i<10;i++){ InternalThread it=new InternalThread(); it.startThread(i); } } //该方法会启动一个匿名线程 public void startThread(int i){ //要传入匿名线程内使用的参数必须定义为final型 final int ID=i; Runnable runnable=new Runnable(){ public void run(){ while(true){ /* * Thread.sleep(long time)方法只是让线程暂停,而非退出 * 休眠时间结束后,VM会将线程重新调为运行状态。当线程在 * sleep状态时,如果VM或其他线程强行终止这个线程,sleep * 方法会抛出InterruptedException异常,这叫做线程中断异常 * 所以,在调用sleep方法时,需要处理或抛出这个异常 */ try{ System.out.println(ID+"号线程已启动"); Thread.sleep(10000); }catch(Exception e){ e.printStackTrace(); } } } }; Thread thread=new Thread(runnable); thread.start(); } }
更多多线程之匿名内部类相关文章请关注PHP中文网!

Outils d'IA chauds

Undresser.AI Undress
Application basée sur l'IA pour créer des photos de nu réalistes

AI Clothes Remover
Outil d'IA en ligne pour supprimer les vêtements des photos.

Undress AI Tool
Images de déshabillage gratuites

Clothoff.io
Dissolvant de vêtements AI

AI Hentai Generator
Générez AI Hentai gratuitement.

Article chaud

Outils chauds

Bloc-notes++7.3.1
Éditeur de code facile à utiliser et gratuit

SublimeText3 version chinoise
Version chinoise, très simple à utiliser

Envoyer Studio 13.0.1
Puissant environnement de développement intégré PHP

Dreamweaver CS6
Outils de développement Web visuel

SublimeText3 version Mac
Logiciel d'édition de code au niveau de Dieu (SublimeText3)

Les classes internes anonymes peuvent provoquer des fuites de mémoire. Le problème est qu'elles contiennent une référence à la classe externe, empêchant ainsi la classe externe d'être récupérée. Les solutions incluent : 1. Utiliser des références faibles. Lorsque la classe externe n'est plus détenue par une référence forte, le garbage collector recyclera immédiatement l'objet de référence faible ; 2. Utiliser des références logicielles lorsqu'il sera utilisé. a besoin de mémoire pendant le garbage collection. Ce n'est qu'alors que l'objet de référence logiciel est recyclé. En combat réel, comme dans les applications Android, le problème de fuite de mémoire provoqué par des classes internes anonymes peut être résolu en utilisant des références faibles, de sorte que la classe interne anonyme puisse être recyclée lorsque l'écouteur n'est pas nécessaire.

Les classes internes anonymes sont des classes internes spéciales en Java qui n'ont pas de nom explicite et sont créées via la nouvelle expression. Elles sont principalement utilisées pour implémenter des interfaces spécifiques ou étendre des classes abstraites et sont utilisées immédiatement après la création. Les modèles de conception de classe interne anonymes courants incluent : Modèle d’adaptateur : convertit une interface en une autre interface. Modèle de stratégie : définition et algorithmes de remplacement. Modèle d'observateur : enregistrez les observateurs et gérez les événements. C'est très utile dans des applications pratiques, telles que le tri d'un TreeSet par longueur de chaîne, la création de threads anonymes, etc.

Les classes internes anonymes sont utilisées en Java en tant que classes internes spéciales qui facilitent le sous-classement, la simplification du code et la gestion des événements (tels que les clics sur des boutons). Les cas pratiques incluent : Gestion des événements : utilisez des classes internes anonymes pour ajouter des écouteurs d'événements de clic pour les boutons. Transformation des données : triez les collections à l'aide de la méthode Collections.sort et d'une classe interne anonyme comme comparateur.

Les classes internes anonymes ne conviennent pas lorsque : besoin d'accéder à des membres privés, besoin de plusieurs instances, besoin d'héritage, besoin d'accéder à des types génériques

Erreur d'utilisation de classe interne anonyme : accès à une variable hors de portée en interceptant une exception non déclarée dans un environnement non thread-safe

Le problème de performances des classes internes anonymes est qu'elles sont recréées à chaque fois qu'elles sont utilisées, ce qui peut être optimisé grâce aux stratégies suivantes : 1. Stocker les classes internes anonymes dans des variables locales 2. Utiliser des classes internes non statiques 3. Utiliser lambda ; expressions. Des tests pratiques montrent que l'optimisation de l'expression lambda a le meilleur effet.

La durée de vie d'une classe interne anonyme est déterminée par sa portée : Classe interne locale à la méthode : valide uniquement dans la portée de la méthode qui l'a créée. Classe interne du constructeur : liée à l'instance de classe externe et libérée lorsque l'instance de classe externe est libérée. Classes internes statiques : chargées et déchargées en même temps que les classes externes.

Les classes internes anonymes simplifient la création de code multithread, éliminant le besoin de nommer et permettant la définition et l'utilisation instantanées des classes de thread. Le principal avantage est de simplifier le code, tandis que la limitation est qu'il ne peut pas être étendu. À utiliser lorsque vous devez créer rapidement un ou deux threads. Gardez le code court. Si une logique plus complexe est requise, un fichier de classe distinct doit être créé.
