обьясните как работает

150

16 декабря 2020, 15:20

есть метод,помогите пожалуйста понять,как он работает

public static int process(int[][] data) throws InterruptedException {
        final AtomicInteger c = new AtomicInteger(0);
        final Thread[] p = new Thread[data.length];
        for (int i = 0; i < p.length; i++) {
            final int[] r = data[i];
            p[i] = new Thread(() -> {
                for (int s0 = 0; s0 < r.length - 1; s0++) {
                    final int s1 = s0 + 1;
                    if (r[s0] > r[s1]) {
                        final int tmp = r[s0];
                        r[s0] = r[s1];
                        r[s1] = tmp;
                        c.incrementAndGet();
                    }
                }
            });
            p[i].start();
        }
        for (Thread t : p) {
            t.join();
        }
        return c.get();
    }

я не совсем понимаю,некоторые строки,точнее этот кусок,что он делает и можно ли переписать без лямбды

p[i] = new Thread(() -> {
                for (int s0 = 0; s0 < r.length - 1; s0++) {
                    final int s1 = s0 + 1;
                    if (r[s0] > r[s1]) {
                        final int tmp = r[s0];
                        r[s0] = r[s1];
                        r[s1] = tmp;
                        c.incrementAndGet();
                    }
                }

для чего прибавлять+1 в этой строке

 final int s1 = s0 + 1;

и что делает эта часть?

c.incrementAndGet();

спасибо

Answer 1

Начну с конца.

Ваша строка c.incrementAndGet(); согласно документации увеличивает текущее значение c и берет его значение, равносильно записям с обычным int, например, как

int c=0;
System.out.println(++c);

Атомик используется, так как у вас многопоточное (Thread) приложение и вам нужны объекты, которые не смогут быть изменены другими потоками в то время как 1 какой-то поток уже обращается к переменной этого объекта.

Строка final int s1 = s0 + 1; создает переменную s1 которая не должна быть измененной во время работы программы в области ее объявляения, то есть внутри for(;;).

Почему столько много переменных, может объяснить этот сайт. Потому что у вас двумерный массив и вам нужно пройтись по всем его элементам.

Например, у вас будет так

 int[][] data={{1,2,3},{2,3,4}};

Вы сначала должны, но не обязаны, пробежаться по строкам, которая будет содержать столбцы. В данном случае, у вас 2 строки с 3 столбцами.

В вашем цикле вы создаете

 final Thread[] p = new Thread[data.length];

массив потоков размером равным количеству строк. В моем примере это 2 Потом вы бежите по каждой строке и

 final int[] r = data[i];

создаете массив r который будет равен количеству ваших столбцов. В моем примере их 3.

После этого, для каждого столбца, это видно по строчке

for (int i = 0; i < p.length; i++) {

вы создаете новый поток ( Thread ) через лямбду, внутри которого вы делаете что-то, а именно

for (int s0 = 0; s0 < 3 - 1; s0++) {
    final int s1 = 0 + 1;
    if (r[0] > r[1]) {
    final int tmp = r[0];
    r[0] = r[1];
    r[1] = tmp;
    c.incrementAndGet();
}

Всё это можно делать как

Thread newThread= new Thread(new Runnable() {
                           @Override
                           public void run() {
                               for (int s0 = 0; s0 < r.length - 1; s0++) {
                                   int s1 = s0 + 1;
                                   if (r[s0] > r[s1]) {
                                       final int tmp = r[s0];
                                       r[s0] = r[s1];
                                       r[s1] = tmp;
                                       c.incrementAndGet();
                                   }
                               }
                           }
                       });
p[i] = newThread;

Этот пример, насколько я понял, иллюстрирует сортировку выбором. О сортировках можно посмотреть тут