programmation simultanée Java (4) performances et évolutivité

Performance et évolutivité

1. Loi d'Amdahl

1. La relation entre problèmes et ressources

Dans certains problèmes, plus il y a de ressources, plus la solution est rapide. les questions sont à l'opposé :

Remarque : chaque programme doit avoir une partie série, et l'impact des parties série et parallèle sur le programme doit être raisonnablement analysé. Extrêmement important ; est une relation exponentielle entre la proportion de la partie série et l'efficacité d'exécution multicœur

2.ConcurrentLinkedQueue

Dans un environnement multicœur, cette file d'attente thread-safe est plus efficace que la file d'attente généré via synchroniséList La vitesse est beaucoup plus rapide

On peut dire que les classes fournies en simultané sont plus rapides que les classes thread-safe générées par les méthodes

2. Surcharge de thread

Étant donné que le multi-threading a des frais généraux : par conséquent, l'utilisation du multi-threading doit assurer une amélioration des performances>Surcharge de concurrence

Surcharge de changement de contexte

 ; .Réduire la concurrence entre les verrous

　1. Réduire le temps de maintien du verrou : réduire la portée du verrou

private final Map<String, String> attributes = new HashMap<String, String>();//整个方法上锁public synchronized boolean userLocationMatches(String name, String regexp) {
        String key = "users." + name + ".location";
        String location = attributes.get(key);if (location == null)return false;elsereturn Pattern.matches(regexp, location);
    }public boolean userLocationMatches(String name, String regexp) {
        String key = "users." + name + ".location";
        String location;//只针对可变状态上锁synchronized (this) {
            location = attributes.get(key);
        }if (location == null)return false;elsereturn Pattern.matches(regexp, location);
    }

　2. Réduire la fréquence. de demandes de verrous : décomposition de verrous, division de verrous Section...

Décomposition de verrous : Décomposer un verrou en plusieurs verrous Par exemple : il n'est pas nécessaire de mettre à jour plusieurs variables d'état dans une opération atomique, mais chaque variable d'état. utilise le même verrou de classe Si nécessaire, utilisez simplement son propre verrou pour chaque variable d'état non pertinente

public class ServerStatusBeforeSplit {public final Set<String> users;public final Set<String> queries;public ServerStatusBeforeSplit() {
        users = new HashSet<String>();
        queries = new HashSet<String>();
    }//每个方法使用 当前class实例锁，类似于synchronized(this),不管是否是操作同一共享状态public synchronized void addUser(String u) {
        users.add(u);
    }public synchronized void addQuery(String q) {
        queries.add(q);
    }public synchronized void removeUser(String u) {
        users.remove(u);
    }public synchronized void removeQuery(String q) {
        queries.remove(q);
    }
}public class ServerStatusAfterSplit {public final Set<String> users;public final Set<String> queries;//操作同一 状态的方法 使用相同的锁public ServerStatusAfterSplit() {
        users = new HashSet<String>();
        queries = new HashSet<String>();
    }public void addUser(String u) {synchronized (users) {
            users.add(u);
        }
    }public void addQuery(String q) {synchronized (queries) {
            queries.add(q);
        }
    }public void removeUser(String u) {synchronized (users) {
            users.remove(u);
        }
    }public void removeQuery(String q) {synchronized (users) {
            queries.remove(q);
        }
    }
}

　

Segmentation du verrou : telle. en tant que map bucket, divisez-le en différents segments, et chaque segment a un verrou. De cette façon, lors de l'exécution de certaines opérations telles que get, vous pouvez détenir différents verrous pour améliorer l'efficacité de la concurrence. Bien sûr, certaines opérations doivent détenir les verrous de tous. segments du conteneur en même temps, comme clair, etc.

//Map分段锁实现public class StripedMap {// Synchronization policy: buckets[n] guarded by locks[n%N_LOCKS]private static final int N_LOCKS = 16;  //锁数量private final Node[] buckets;           //容器桶private final Object[] locks;           //同步监听器对象数组private static class Node {
        Node next;
        Object key;
        Object value;
    }public StripedMap(int numBuckets) {
        buckets = new Node[numBuckets];
        locks = new Object[N_LOCKS];for (int i = 0; i < N_LOCKS; i++)
            locks[i] = new Object();
    }private final int hash(Object key) {return Math.abs(key.hashCode() % buckets.length);
    }public Object get(Object key) {int hash = hash(key);//获取当前 key对应的index区域的锁，只获取了一个锁synchronized (locks[hash % N_LOCKS]) {for (Node m = buckets[hash]; m != null; m = m.next)if (m.key.equals(key))return m.value;
        }return null;
    }public void clear() {for (int i = 0; i < buckets.length; i++) {//获取 每个i对应的锁，就是获取了整个容器所有的分段锁synchronized (locks[i % N_LOCKS]) {
                buckets[i] = null;
            }
        }
    }
}

　3. Évitez les zones sensibles

　La concurrence pour les verrous des ressources hotspot est féroce, entraînant des problèmes de performances

4. Remplacer les verrous exclusifs

Par exemple : verrouillage en lecture-écriture : la lecture et la lecture peuvent être parallélisées pour éviter utilisation exclusive ; utiliser des quantités d'état atomiques ; utiliser des conteneurs simultanés ; utiliser des objets immuables, etc.

5. Réduire le changement de contexte

Le changement de tâche entre les états bloquants et non bloquants est similaire à un changement de contexte.

Par exemple : les opérations de journalisation, d'impression de journal et d'E/S entraîneront un grand nombre de blocages et de libérations, provoquant des problèmes de performances

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!